
'''simple docstring'''






from __future__ import annotations

import math

import numpy as np
from numpy.linalg import norm







def 		A_							(						_lowerCAmelCase :     np.ndarray					,						_lowerCAmelCase :     np.ndarray				):



      """simple docstring"""




      return math.sqrt(sum(pow(a - b					,						2				) for a, b in zip(_lowerCAmelCase					,						_lowerCAmelCase				)				)				)







def 		A_							(						_lowerCAmelCase :     np.ndarray					,						_lowerCAmelCase :     np.ndarray				):



      """simple docstring"""




      if dataset.ndim != value_array.ndim:
            _lowerCamelCase					: Tuple		    = (
                "Wrong input data's dimensions... "
                F'dataset : {dataset.ndim}, value_array : {value_array.ndim}'
            )
            raise ValueError(_lowerCAmelCase				)

      try:
            if dataset.shape[1] != value_array.shape[1]:
                  _lowerCamelCase					: Tuple		    = (
                      "Wrong input data's shape... "
                      F'dataset : {dataset.shape[1]}, value_array : {value_array.shape[1]}'
                  )
                  raise ValueError(_lowerCAmelCase				)
      except IndexError:
            if dataset.ndim != value_array.ndim:
                  raise TypeError("Wrong shape"				)

      if dataset.dtype != value_array.dtype:
            _lowerCamelCase					: List[str]		    = (
                "Input data have different datatype... "
                F'dataset : {dataset.dtype}, value_array : {value_array.dtype}'
            )
            raise TypeError(_lowerCAmelCase				)

      _lowerCamelCase					: Optional[int]		    = []

      for value in value_array:
            _lowerCamelCase					: Optional[int]		    = euclidean(_lowerCAmelCase					,						dataset[0]				)
            _lowerCamelCase					: Union[str, Any]		    = dataset[0].tolist()

            for dataset_value in dataset[1:]:
                  _lowerCamelCase					: int		    = euclidean(_lowerCAmelCase					,						_lowerCAmelCase				)

                  if dist > temp_dist:
                        _lowerCamelCase					: int		    = temp_dist
                        _lowerCamelCase					: Union[str, Any]		    = dataset_value.tolist()

            answer.append([vector, dist]				)

      return answer







def 		A_							(						_lowerCAmelCase :     np.ndarray					,						_lowerCAmelCase :     np.ndarray				):



      """simple docstring"""




      return np.dot(_lowerCAmelCase					,						_lowerCAmelCase				) / (norm(_lowerCAmelCase				) * norm(_lowerCAmelCase				))


if __name__ == "__main__":
 import doctest

 doctest.testmod()
'''simple docstring'''




import unittest
from typing import Tuple

import torch

from diffusers.utils import floats_tensor, randn_tensor, torch_all_close, torch_device
from diffusers.utils.testing_utils import require_torch




@require_torch
class        a__ :






     @property
     def   SCREAMING_SNAKE_CASE__  (					self						:						str       ):





         """simple docstring"""



         return self.get_dummy_input()






     @property
     def   SCREAMING_SNAKE_CASE__  (					self						:						str       ):





         """simple docstring"""



         if self.block_type == "down":
             return (4, 32, 16, 16)
         elif self.block_type == "mid":
             return (4, 32, 32, 32)
         elif self.block_type == "up":
             return (4, 32, 64, 64)

         raise ValueError(f"""'{self.block_type}' is not a supported block_type. Set it to 'up', 'mid', or 'down'."""       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[Any]    ,							a						:						List[Any]=True    ,							a						:						Dict=False    ,							a						:						Optional[Any]=False    ,							a						:						List[Any]=False    ,							):





         """simple docstring"""



         __lowerCamelCase            =    4
         __lowerCamelCase            =    32
         __lowerCamelCase            =    (32, 32)

         __lowerCamelCase            =    torch.manual_seed(0       )
         __lowerCamelCase            =    torch.device(a       )
         __lowerCamelCase            =    (batch_size, num_channels) + sizes
         __lowerCamelCase            =    randn_tensor(a    ,							generator=a    ,							device=a       )
         __lowerCamelCase            =    {'''hidden_states''': hidden_states}

         if include_temb:
             __lowerCamelCase            =    1_28
             __lowerCamelCase            =    randn_tensor((batch_size, temb_channels)    ,							generator=a    ,							device=a       )

         if include_res_hidden_states_tuple:
             __lowerCamelCase            =    torch.manual_seed(1       )
             __lowerCamelCase            =    (randn_tensor(a    ,							generator=a    ,							device=a       ),)

         if include_encoder_hidden_states:
             __lowerCamelCase            =    floats_tensor((batch_size, 32, 32)       ).to(a       )

         if include_skip_sample:
             __lowerCamelCase            =    randn_tensor(((batch_size, 3) + sizes)    ,							generator=a    ,							device=a       )

         return dummy_input






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[int]       ):





         """simple docstring"""



         __lowerCamelCase            =    {
             '''in_channels''': 32,
             '''out_channels''': 32,
             '''temb_channels''': 1_28,
         }
         if self.block_type == "up":
             __lowerCamelCase            =    32

         if self.block_type == "mid":
             init_dict.pop('''out_channels'''       )

         __lowerCamelCase            =    self.dummy_input
         return init_dict, inputs_dict






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[Any]    ,							a						:						List[str]       ):





         """simple docstring"""



         __lowerCamelCase      ,    __lowerCamelCase            =    self.prepare_init_args_and_inputs_for_common()
         __lowerCamelCase            =    self.block_class(**a       )
         unet_block.to(a       )
         unet_block.eval()

         with torch.no_grad():
             __lowerCamelCase            =    unet_block(**a       )

         if isinstance(a    ,							a       ):
             __lowerCamelCase            =    output[0]

         self.assertEqual(output.shape    ,							self.output_shape       )

         __lowerCamelCase            =    output[0, -1, -3:, -3:]
         __lowerCamelCase            =    torch.tensor(a       ).to(a       )
         assert torch_all_close(output_slice.flatten()    ,							a    ,							atol=5e-3       )






     @unittest.skipIf(torch_device == '''mps'''    ,							'''Training is not supported in mps'''       )
     def   SCREAMING_SNAKE_CASE__  (					self						:						Any       ):





         """simple docstring"""



         __lowerCamelCase      ,    __lowerCamelCase            =    self.prepare_init_args_and_inputs_for_common()
         __lowerCamelCase            =    self.block_class(**a       )
         model.to(a       )
         model.train()
         __lowerCamelCase            =    model(**a       )

         if isinstance(a    ,							a       ):
             __lowerCamelCase            =    output[0]

         __lowerCamelCase            =    torch.device(a       )
         __lowerCamelCase            =    randn_tensor(output.shape    ,							device=a       )
         __lowerCamelCase            =    torch.nn.functional.mse_loss(a    ,							a       )
         loss.backward()
