import flax.linen as nn
import jax
import jax.numpy as jnp



class __snake_case    (						nn.Module		):
   lowerCAmelCase_														=							42
   lowerCAmelCase_														=							jnp.floataa




   def      __a						(   self      :    Dict				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				nn.Conv(
         self.out_channels	,     kernel_size=(3, 3)	,     strides=(1, 1)	,     padding=((1, 1), (1, 1))	,     dtype=self.dtype	,     )




   def __call__(   self      :    Tuple	,     _lowercase      :    str				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__							,					SCREAMING_SNAKE_CASE__							,					SCREAMING_SNAKE_CASE__							,					SCREAMING_SNAKE_CASE__      							=				hidden_states.shape
     SCREAMING_SNAKE_CASE__      							=				jax.image.resize(
         _lowercase	,     shape=(batch, height * 2, width * 2, channels)	,     method="""nearest"""	,     )
     SCREAMING_SNAKE_CASE__      							=				self.conv(_lowercase				)
     return hidden_states





class __snake_case    (						nn.Module		):
   lowerCAmelCase_														=							42
   lowerCAmelCase_														=							jnp.floataa




   def      __a						(   self      :    Optional[int]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				nn.Conv(
         self.out_channels	,     kernel_size=(3, 3)	,     strides=(2, 2)	,     padding=((1, 1), (1, 1))	,     dtype=self.dtype	,     )




   def __call__(   self      :    int	,     _lowercase      :    Tuple				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				self.conv(_lowercase				)
     return hidden_states





class __snake_case    (						nn.Module		):
   lowerCAmelCase_														=							42
   lowerCAmelCase_														=							None
   lowerCAmelCase_														=							0.0
   lowerCAmelCase_														=							None
   lowerCAmelCase_														=							jnp.floataa




   def      __a						(   self      :    Tuple				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				self.in_channels if self.out_channels is None else self.out_channels

     SCREAMING_SNAKE_CASE__      							=				nn.GroupNorm(num_groups=32	,     epsilon=1E-5				)
     SCREAMING_SNAKE_CASE__      							=				nn.Conv(
         _lowercase	,     kernel_size=(3, 3)	,     strides=(1, 1)	,     padding=((1, 1), (1, 1))	,     dtype=self.dtype	,     )

     SCREAMING_SNAKE_CASE__      							=				nn.Dense(_lowercase	,     dtype=self.dtype				)

     SCREAMING_SNAKE_CASE__      							=				nn.GroupNorm(num_groups=32	,     epsilon=1E-5				)
     SCREAMING_SNAKE_CASE__      							=				nn.Dropout(self.dropout_prob				)
     SCREAMING_SNAKE_CASE__      							=				nn.Conv(
         _lowercase	,     kernel_size=(3, 3)	,     strides=(1, 1)	,     padding=((1, 1), (1, 1))	,     dtype=self.dtype	,     )

     SCREAMING_SNAKE_CASE__      							=				self.in_channels != out_channels if self.use_nin_shortcut is None else self.use_nin_shortcut

     SCREAMING_SNAKE_CASE__      							=				None
     if use_nin_shortcut:
       SCREAMING_SNAKE_CASE__      							=				nn.Conv(
           _lowercase	,     kernel_size=(1, 1)	,     strides=(1, 1)	,     padding="""VALID"""	,     dtype=self.dtype	,     )




   def __call__(   self      :    List[str]	,     _lowercase      :    Any	,     _lowercase      :    Optional[int]	,     _lowercase      :    Optional[int]=True				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				hidden_states
     SCREAMING_SNAKE_CASE__      							=				self.norma(_lowercase				)
     SCREAMING_SNAKE_CASE__      							=				nn.swish(_lowercase				)
     SCREAMING_SNAKE_CASE__      							=				self.conva(_lowercase				)

     SCREAMING_SNAKE_CASE__      							=				self.time_emb_proj(nn.swish(_lowercase				)				)
     SCREAMING_SNAKE_CASE__      							=				jnp.expand_dims(jnp.expand_dims(_lowercase	,     1				)	,     1				)
     SCREAMING_SNAKE_CASE__      							=				hidden_states + temb

     SCREAMING_SNAKE_CASE__      							=				self.norma(_lowercase				)
     SCREAMING_SNAKE_CASE__      							=				nn.swish(_lowercase				)
     SCREAMING_SNAKE_CASE__      							=				self.dropout(_lowercase	,     _lowercase				)
     SCREAMING_SNAKE_CASE__      							=				self.conva(_lowercase				)

     if self.conv_shortcut is not None:
       SCREAMING_SNAKE_CASE__      							=				self.conv_shortcut(_lowercase				)

     return hidden_states + residual

import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)







class __snake_case    (						unittest.TestCase		):




   def      __a						(   self      :    Dict				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3]				)
     self.assertEqual(x.component(0				)	,     1				)
     self.assertEqual(x.component(2				)	,     3				)
     SCREAMING_SNAKE_CASE__      							=				Vector()




   def      __a						(   self      :    int				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([0, 0, 0, 0, 0, 1]				)
     self.assertEqual(str(_lowercase				)	,     """(0,0,0,0,0,1)"""				)




   def      __a						(   self      :    Tuple				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3, 4]				)
     self.assertEqual(len(_lowercase				)	,     4				)




   def      __a						(   self      :    Optional[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2]				)
     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3, 4, 5]				)
     SCREAMING_SNAKE_CASE__      							=				Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]				)
     SCREAMING_SNAKE_CASE__      							=				Vector([1, -1, 1, -1, 2, -3, 4, -5]				)
     self.assertAlmostEqual(x.euclidean_length()	,     2.2_36	,     3				)
     self.assertAlmostEqual(y.euclidean_length()	,     7.4_16	,     3				)
     self.assertEqual(z.euclidean_length()	,     0				)
     self.assertAlmostEqual(w.euclidean_length()	,     7.6_16	,     3				)




   def      __a						(   self      :    Optional[int]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3]				)
     SCREAMING_SNAKE_CASE__      							=				Vector([1, 1, 1]				)
     self.assertEqual((x + y).component(0				)	,     2				)
     self.assertEqual((x + y).component(1				)	,     3				)
     self.assertEqual((x + y).component(2				)	,     4				)




   def      __a						(   self      :    Any				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3]				)
     SCREAMING_SNAKE_CASE__      							=				Vector([1, 1, 1]				)
     self.assertEqual((x - y).component(0				)	,     0				)
     self.assertEqual((x - y).component(1				)	,     1				)
     self.assertEqual((x - y).component(2				)	,     2				)




   def      __a						(   self      :    str				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3]				)
     SCREAMING_SNAKE_CASE__      							=				Vector([2, -1, 4]				)  # for test of dot product
     SCREAMING_SNAKE_CASE__      							=				Vector([1, -2, -1]				)
     self.assertEqual(str(x * 3.0				)	,     """(3.0,6.0,9.0)"""				)
     self.assertEqual((a * b)	,     0				)




   def      __a						(   self      :    Union[str, Any]				):



     """simple docstring"""






     self.assertEqual(str(zero_vector(10				)				).count("""0"""				)	,     10				)




   def      __a						(   self      :    str				):



     """simple docstring"""






     self.assertEqual(str(unit_basis_vector(3	,     1				)				)	,     """(0,1,0)"""				)




   def      __a						(   self      :    Any				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3]				)
     SCREAMING_SNAKE_CASE__      							=				Vector([1, 0, 1]				)
     self.assertEqual(str(axpy(2	,     _lowercase	,     _lowercase				)				)	,     """(3,4,7)"""				)




   def      __a						(   self      :    str				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 0, 0, 0, 0, 0]				)
     SCREAMING_SNAKE_CASE__      							=				x.copy()
     self.assertEqual(str(_lowercase				)	,     str(_lowercase				)				)




   def      __a						(   self      :    str				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 0, 0]				)
     x.change_component(0	,     0				)
     x.change_component(1	,     1				)
     self.assertEqual(str(_lowercase				)	,     """(0,1,0)"""				)




   def      __a						(   self      :    Optional[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]	,     3	,     3				)
     self.assertEqual("""|1,2,3|\n|2,4,5|\n|6,7,8|\n"""	,     str(_lowercase				)				)




   def      __a						(   self      :    List[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]	,     3	,     3				)
     SCREAMING_SNAKE_CASE__      							=				[[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
     for x in range(a.height()				):
       for y in range(a.width()				):
         self.assertEqual(minors[x][y]	,     a.minor(_lowercase	,     _lowercase				)				)




   def      __a						(   self      :    Dict				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]	,     3	,     3				)
     SCREAMING_SNAKE_CASE__      							=				[[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
     for x in range(a.height()				):
       for y in range(a.width()				):
         self.assertEqual(cofactors[x][y]	,     a.cofactor(_lowercase	,     _lowercase				)				)




   def      __a						(   self      :    Union[str, Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]	,     3	,     3				)
     self.assertEqual(-5	,     a.determinant()				)




   def      __a						(   self      :    List[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]	,     3	,     3				)
     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3]				)
     self.assertEqual("""(14,32,50)"""	,     str(a * x				)				)
     self.assertEqual("""|2,4,6|\n|8,10,12|\n|14,16,18|\n"""	,     str(a * 2				)				)




   def      __a						(   self      :    Optional[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]	,     3	,     3				)
     a.change_component(0	,     2	,     5				)
     self.assertEqual("""|1,2,5|\n|2,4,5|\n|6,7,8|\n"""	,     str(_lowercase				)				)




   def      __a						(   self      :    Union[str, Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]	,     3	,     3				)
     self.assertEqual(7	,     a.component(2	,     1				)	,     0.01				)




   def      __a						(   self      :    List[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]	,     3	,     3				)
     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]	,     3	,     3				)
     self.assertEqual("""|2,4,10|\n|4,8,10|\n|12,14,18|\n"""	,     str(a + b				)				)




   def      __a						(   self      :    Optional[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]	,     3	,     3				)
     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]	,     3	,     3				)
     self.assertEqual("""|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"""	,     str(a - b				)				)




   def      __a						(   self      :    Any				):



     """simple docstring"""






     self.assertEqual(
         """|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n"""	,     str(square_zero_matrix(5				)				)	,     )


if __name__ == "__main__":
   unittest.main()
