



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    _A	(     __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE				,unittest.TestCase   ):
       UpperCamelCase__  :   Union[str, Any]						 =						VQModel
       UpperCamelCase__  :   List[Any]						 =						'sample'



       @property
       def 		_lowerCamelCase      (		self							:					Any					,		__SCREAMING_SNAKE_CASE							:					List[str]=(32, 32)):


           '''simple docstring'''

           __a							=    4
           __a							=    3

           __a							=    floats_tensor((batch_size, num_channels) + sizes).to(_a)

           return {"sample": image}



       @property
       def 		_lowerCamelCase      (		self							:					List[str]):


           '''simple docstring'''

           return (3, 32, 32)



       @property
       def 		_lowerCamelCase      (		self							:					List[Any]):


           '''simple docstring'''

           return (3, 32, 32)



       def 		_lowerCamelCase      (		self							:					Optional[int]):


           '''simple docstring'''

           __a							=    {
               '''block_out_channels''': [32, 64],
               '''in_channels''': 3,
               '''out_channels''': 3,
               '''down_block_types''': ['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''],
               '''up_block_types''': ['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''],
               '''latent_channels''': 3,
           }
           __a							=    self.dummy_input
           return init_dict, inputs_dict



       def 		_lowerCamelCase      (		self							:					Dict):


           '''simple docstring'''

           pass



       def 		_lowerCamelCase      (		self							:					Tuple):


           '''simple docstring'''

           pass



       def 		_lowerCamelCase      (		self							:					Optional[Any]):


           '''simple docstring'''

           __a	,       __a							=    VQModel.from_pretrained('''fusing/vqgan-dummy'''					,		output_loading_info=_a)
           self.assertIsNotNone(_a)
           self.assertEqual(len(loading_info['''missing_keys'''])					,		0)

           model.to(_a)
           __a							=    model(**self.dummy_input)

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





       def 		_lowerCamelCase      (		self							:					Tuple):


           '''simple docstring'''

           __a							=    VQModel.from_pretrained('''fusing/vqgan-dummy''')
           model.to(_a).eval()

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

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

           __a							=    output[0, -1, -3:, -3:].flatten().cpu()
           # fmt: off
           __a							=    torch.tensor([-0.01_53, -0.40_44, -0.18_80, -0.51_61, -0.24_18, -0.40_72, -0.16_12, -0.06_33, -0.01_43])
           # fmt: on
           self.assertTrue(torch.allclose(_a					,		_a					,		atol=1E-3))










def 					__snake_case     (      _UpperCAmelCase = 1000000    ):
    __a							=    limit + 1
    __a							=    [0] * limit
    for first_term in range(1       ,			_UpperCAmelCase    ):
        for n in range(_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase    ):
            __a							=    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

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

    return count


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





