
"""simple docstring"""



import unittest

import torch

from diffusers import VQModel
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()

class       lowerCAmelCase__				(						A_ ,	A_ ,	unittest.TestCase	):
     __a						=					VQModel
     __a						=					"""sample"""







     @property
     def      lowercase	(							self			:			Optional[int]    ,      _lowerCamelCase			:			str=(32, 32)			):
       _snake_case					     =       4
       _snake_case					     =       3

       _snake_case					     =       floats_tensor((batch_size, num_channels) + sizes			).to(_lowerCamelCase			)

       return {"sample": image}







     @property
     def      lowercase	(							self			:			List[Any]			):
       return (3, 32, 32)







     @property
     def      lowercase	(							self			:			List[Any]			):
       return (3, 32, 32)







     def      lowercase	(							self			:			Dict			):
       _snake_case					     =       {
           '''block_out_channels''': [32, 64],
           '''in_channels''': 3,
           '''out_channels''': 3,
           '''down_block_types''': ['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''],
           '''up_block_types''': ['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''],
           '''latent_channels''': 3,
       }
       _snake_case					     =       self.dummy_input
       return init_dict, inputs_dict







     def      lowercase	(							self			:			Union[str, Any]			):
       pass







     def      lowercase	(							self			:			Any			):
       pass







     def      lowercase	(							self			:			Optional[int]			):
       _snake_case     ,					_snake_case					     =       VQModel.from_pretrained('''fusing/vqgan-dummy'''    ,      output_loading_info=_lowerCamelCase			)
       self.assertIsNotNone(_lowerCamelCase			)
       self.assertEqual(len(loading_info['''missing_keys''']			)    ,      0			)

       model.to(_lowerCamelCase			)
       _snake_case					     =       model(**self.dummy_input			)

       assert image is not None, "Make sure output is not None"







     def      lowercase	(							self			:			Dict			):
       _snake_case					     =       VQModel.from_pretrained('''fusing/vqgan-dummy'''			)
       model.to(_lowerCamelCase			).eval()

       torch.manual_seed(0			)
       if torch.cuda.is_available():
         torch.cuda.manual_seed_all(0			)

       _snake_case					     =       torch.randn(1    ,      model.config.in_channels    ,      model.config.sample_size    ,      model.config.sample_size			)
       _snake_case					     =       image.to(_lowerCamelCase			)
       with torch.no_grad():
         _snake_case					     =       model(_lowerCamelCase			).sample

       _snake_case					     =       output[0, -1, -3:, -3:].flatten().cpu()
       # fmt: off
       _snake_case					     =       torch.tensor([-0.0_1_5_3, -0.4_0_4_4, -0.1_8_8_0, -0.5_1_6_1, -0.2_4_1_8, -0.4_0_7_2, -0.1_6_1_2, -0.0_6_3_3, -0.0_1_4_3]			)
       # fmt: on
       self.assertTrue(torch.allclose(_lowerCamelCase    ,      _lowerCamelCase    ,      atol=1e-3			)			)





"""simple docstring"""



def 					_UpperCAmelCase      ( __lowerCamelCase   :       int = 1_00_00_00		)     ->					int:
  _snake_case					     =       limit + 1
  _snake_case					     =       [0] * limit
  for first_term in range(1 ,					__lowerCamelCase		):
    for n in range(__lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase		):
      _snake_case					     =       first_term + n / first_term
      if common_difference % 4:  # d must be divisble by 4
        continue
      else:
        common_difference /= 4
        if (
            first_term > common_difference
            and first_term < 4 * common_difference
        ):  # since x,y,z are positive integers
          frequency[n] += 1  # so z>0 and a>d ,also 4d<a

  _snake_case					     =       sum(1 for x in frequency[1:limit] if x == 10		)

  return count


if __name__ == "__main__":
 print(F"{solution() = }")



