
'''simple docstring'''





import unittest

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






class 							UpperCAmelCase_							(    unittest.TestCase				):

 '''simple docstring'''







 def 							UpperCamelCase  (					self		:  Dict ):



   '''simple docstring'''




   UpperCAmelCase__      :					int				       =							Vector([1, 2, 3] )
   self.assertEqual(x.component(0 )			,				1 )
   self.assertEqual(x.component(2 )			,				3 )
   UpperCAmelCase__      :					Optional[int]				       =							Vector()







 def 							UpperCamelCase  (					self		:  str ):



   '''simple docstring'''




   UpperCAmelCase__      :					Optional[int]				       =							Vector([0, 0, 0, 0, 0, 1] )
   self.assertEqual(str(snake_case__ )			,				"(0,0,0,0,0,1)" )







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



   '''simple docstring'''




   UpperCAmelCase__      :					Optional[int]				       =							Vector([1, 2, 3, 4] )
   self.assertEqual(len(snake_case__ )			,				4 )







 def 							UpperCamelCase  (					self		:  Tuple ):



   '''simple docstring'''




   UpperCAmelCase__      :					Union[str, Any]				       =							Vector([1, 2] )
   UpperCAmelCase__      :					int				       =							Vector([1, 2, 3, 4, 5] )
   UpperCAmelCase__      :					List[str]				       =							Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0] )
   UpperCAmelCase__      :					List[Any]				       =							Vector([1, -1, 1, -1, 2, -3, 4, -5] )
   self.assertAlmostEqual(x.euclidean_length()			,				2.236			,				3 )
   self.assertAlmostEqual(y.euclidean_length()			,				7.416			,				3 )
   self.assertEqual(z.euclidean_length()			,				0 )
   self.assertAlmostEqual(w.euclidean_length()			,				7.616			,				3 )







 def 							UpperCamelCase  (					self		:  Optional[int] ):



   '''simple docstring'''




   UpperCAmelCase__      :					Tuple				       =							Vector([1, 2, 3] )
   UpperCAmelCase__      :					List[str]				       =							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 							UpperCamelCase  (					self		:  int ):



   '''simple docstring'''




   UpperCAmelCase__      :					Tuple				       =							Vector([1, 2, 3] )
   UpperCAmelCase__      :					Tuple				       =							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 							UpperCamelCase  (					self		:  Tuple ):



   '''simple docstring'''




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







 def 							UpperCamelCase  (					self		:  Dict ):



   '''simple docstring'''




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







 def 							UpperCamelCase  (					self		:  Tuple ):



   '''simple docstring'''




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







 def 							UpperCamelCase  (					self		:  Tuple ):



   '''simple docstring'''




   UpperCAmelCase__      :					int				       =							Vector([1, 2, 3] )
   UpperCAmelCase__      :					Optional[int]				       =							Vector([1, 0, 1] )
   self.assertEqual(str(axpy(2			,				snake_case__			,				snake_case__ ) )			,				"(3,4,7)" )







 def 							UpperCamelCase  (					self		:  Tuple ):



   '''simple docstring'''




   UpperCAmelCase__      :					Any				       =							Vector([1, 0, 0, 0, 0, 0] )
   UpperCAmelCase__      :					str				       =							x.copy()
   self.assertEqual(str(snake_case__ )			,				str(snake_case__ ) )







 def 							UpperCamelCase  (					self		:  Any ):



   '''simple docstring'''




   UpperCAmelCase__      :					str				       =							Vector([1, 0, 0] )
   x.change_component(0			,				0 )
   x.change_component(1			,				1 )
   self.assertEqual(str(snake_case__ )			,				"(0,1,0)" )







 def 							UpperCamelCase  (					self		:  Optional[int] ):



   '''simple docstring'''




   UpperCAmelCase__      :					List[Any]				       =							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(snake_case__ ) )







 def 							UpperCamelCase  (					self		:  List[str] ):



   '''simple docstring'''




   UpperCAmelCase__      :					Tuple				       =							Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,				3			,				3 )
   UpperCAmelCase__      :					Dict				       =							[[-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(snake_case__			,				snake_case__ ) )







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



   '''simple docstring'''




   UpperCAmelCase__      :					List[Any]				       =							Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,				3			,				3 )
   UpperCAmelCase__      :					List[str]				       =							[[-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(snake_case__			,				snake_case__ ) )







 def 							UpperCamelCase  (					self		:  List[Any] ):



   '''simple docstring'''




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







 def 							UpperCamelCase  (					self		:  List[Any] ):



   '''simple docstring'''




   UpperCAmelCase__      :					Tuple				       =							Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]			,				3			,				3 )
   UpperCAmelCase__      :					Any				       =							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 							UpperCamelCase  (					self		:  Optional[int] ):



   '''simple docstring'''




   UpperCAmelCase__      :					Optional[int]				       =							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(snake_case__ ) )







 def 							UpperCamelCase  (					self		:  Any ):



   '''simple docstring'''




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







 def 							UpperCamelCase  (					self		:  Optional[int] ):



   '''simple docstring'''




   UpperCAmelCase__      :					List[str]				       =							Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,				3			,				3 )
   UpperCAmelCase__      :					Any				       =							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 							UpperCamelCase  (					self		:  Dict ):



   '''simple docstring'''




   UpperCAmelCase__      :					int				       =							Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,				3			,				3 )
   UpperCAmelCase__      :					str				       =							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 							UpperCamelCase  (					self		:  int ):



   '''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()





'''simple docstring'''





from dataclasses import dataclass
from typing import Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput, apply_forward_hook
from .modeling_utils import ModelMixin
from .vae import Decoder, DecoderOutput, Encoder, VectorQuantizer






@dataclass
class 							UpperCAmelCase_							(    A				):

 '''simple docstring'''
 lowercase_					:    torch.FloatTensor






class 							UpperCAmelCase_							(    A					,				A				):

 '''simple docstring'''







 @register_to_config
 def __init__(					self		:  List[str]			,				snake_case__		:  int = 3			,				snake_case__		:  int = 3			,				snake_case__		:  Tuple[str] = ("DownEncoderBlock2D",)			,				snake_case__		:  Tuple[str] = ("UpDecoderBlock2D",)			,				snake_case__		:  Tuple[int] = (64,)			,				snake_case__		:  int = 1			,				snake_case__		:  str = "silu"			,				snake_case__		:  int = 3			,				snake_case__		:  int = 32			,				snake_case__		:  int = 2_56			,				snake_case__		:  int = 32			,				snake_case__		:  Optional[int] = None			,				snake_case__		:  float = 0.18215			,				snake_case__		:  str = "group"			,				):



   '''simple docstring'''




   super().__init__()

   # pass init params to Encoder
   UpperCAmelCase__      :					Tuple				       =							Encoder(
       in_channels=snake_case__			,				out_channels=snake_case__			,				down_block_types=snake_case__			,				block_out_channels=snake_case__			,				layers_per_block=snake_case__			,				act_fn=snake_case__			,				norm_num_groups=snake_case__			,				double_z=snake_case__			,				)

   UpperCAmelCase__      :					str				       =							vq_embed_dim if vq_embed_dim is not None else latent_channels

   UpperCAmelCase__      :					Tuple				       =							nn.Convad(snake_case__			,				snake_case__			,				1 )
   UpperCAmelCase__      :					int				       =							VectorQuantizer(snake_case__			,				snake_case__			,				beta=0.25			,				remap=snake_case__			,				sane_index_shape=snake_case__ )
   UpperCAmelCase__      :					Tuple				       =							nn.Convad(snake_case__			,				snake_case__			,				1 )

   # pass init params to Decoder
   UpperCAmelCase__      :					Union[str, Any]				       =							Decoder(
       in_channels=snake_case__			,				out_channels=snake_case__			,				up_block_types=snake_case__			,				block_out_channels=snake_case__			,				layers_per_block=snake_case__			,				act_fn=snake_case__			,				norm_num_groups=snake_case__			,				norm_type=snake_case__			,				)







 @apply_forward_hook
 def 							UpperCamelCase  (					self		:  Union[str, Any]			,				snake_case__		:  torch.FloatTensor			,				snake_case__		:  bool = True ):



   '''simple docstring'''




   UpperCAmelCase__      :					List[Any]				       =							self.encoder(snake_case__ )
   UpperCAmelCase__      :					List[str]				       =							self.quant_conv(snake_case__ )

   if not return_dict:
     return (h,)

   return VQEncoderOutput(latents=snake_case__ )







 @apply_forward_hook
 def 							UpperCamelCase  (					self		:  List[str]			,				snake_case__		:  torch.FloatTensor			,				snake_case__		:  bool = False			,				snake_case__		:  bool = True ):



   '''simple docstring'''




   if not force_not_quantize:
     UpperCAmelCase__       ,			UpperCAmelCase__       ,			UpperCAmelCase__      :					Any				       =							self.quantize(snake_case__ )
   else:
     UpperCAmelCase__      :					Tuple				       =							h
   UpperCAmelCase__      :					int				       =							self.post_quant_conv(snake_case__ )
   UpperCAmelCase__      :					Optional[int]				       =							self.decoder(snake_case__			,				quant if self.config.norm_type == "spatial" else None )

   if not return_dict:
     return (dec,)

   return DecoderOutput(sample=snake_case__ )







 def 							UpperCamelCase  (					self		:  Any			,				snake_case__		:  torch.FloatTensor			,				snake_case__		:  bool = True ):



   '''simple docstring'''




   UpperCAmelCase__      :					Dict				       =							sample
   UpperCAmelCase__      :					int				       =							self.encode(snake_case__ ).latents
   UpperCAmelCase__      :					Any				       =							self.decode(snake_case__ ).sample

   if not return_dict:
     return (dec,)

   return DecoderOutput(sample=snake_case__ )



