



'''simple docstring'''





import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()







class     UpperCAmelCase_       (       unittest.TestCase	):
    """simple docstring"""







    @property
    def lowerCamelCase       (    self					:     Tuple						):
          torch.manual_seed(0						)
          snake_case__  :    Dict    						=      UNetaDModel(
              block_out_channels=(32, 64) ,     layers_per_block=2 ,     sample_size=32 ,     in_channels=3 ,     out_channels=3 ,     down_block_types=("""DownBlock2D""", """AttnDownBlock2D""") ,     up_block_types=("""AttnUpBlock2D""", """UpBlock2D""") ,     )
          return model




    @property
    def lowerCamelCase       (    self					:     str						):
          torch.manual_seed(0						)
          snake_case__  :    Optional[int]    						=      VQModel(
              block_out_channels=[32, 64] ,     in_channels=3 ,     out_channels=3 ,     down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] ,     up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] ,     latent_channels=3 ,     )
          return model




    @property
    def lowerCamelCase       (    self					:     List[str]						):
          torch.manual_seed(0						)
          snake_case__  :    Dict    						=      CLIPTextConfig(
              bos_token_id=0 ,     eos_token_id=2 ,     hidden_size=32 ,     intermediate_size=37 ,     layer_norm_eps=1E-0_5 ,     num_attention_heads=4 ,     num_hidden_layers=5 ,     pad_token_id=1 ,     vocab_size=1_000 ,     )
          return CLIPTextModel(snake_case_						)




    def lowerCamelCase       (    self					:     Optional[Any]						):
          snake_case__  :    List[str]    						=      self.dummy_uncond_unet
          snake_case__  :    int    						=      DDIMScheduler()
          snake_case__  :    Optional[Any]    						=      self.dummy_vq_model

          snake_case__  :    int    						=      LDMPipeline(unet=snake_case_ ,     vqvae=snake_case_ ,     scheduler=snake_case_						)
          ldm.to(snake_case_						)
          ldm.set_progress_bar_config(disable=snake_case_						)

          snake_case__  :    List[Any]    						=      torch.manual_seed(0						)
          snake_case__  :    Dict    						=      ldm(generator=snake_case_ ,     num_inference_steps=2 ,     output_type="""numpy"""						).images

          snake_case__  :    str    						=      torch.manual_seed(0						)
          snake_case__  :    List[Any]    						=      ldm(generator=snake_case_ ,     num_inference_steps=2 ,     output_type="""numpy""" ,     return_dict=snake_case_						)[0]

          snake_case__  :    List[Any]    						=      image[0, -3:, -3:, -1]
          snake_case__  :    List[Any]    						=      image_from_tuple[0, -3:, -3:, -1]

          assert image.shape == (1, 64, 64, 3)
          snake_case__  :    List[Any]    						=      np.array([0.8512, 0.818, 0.6411, 0.6808, 0.4465, 0.5618, 0.46, 0.6231, 0.5172]						)
          snake_case__  :    str    						=      1E-2 if torch_device != """mps""" else 3E-2

          assert np.abs(image_slice.flatten() - expected_slice						).max() < tolerance
          assert np.abs(image_from_tuple_slice.flatten() - expected_slice						).max() < tolerance







@slow
@require_torch
class     UpperCAmelCase_       (       unittest.TestCase	):
    """simple docstring"""







    def lowerCamelCase       (    self					:     Any						):
          snake_case__  :    int    						=      LDMPipeline.from_pretrained("""CompVis/ldm-celebahq-256"""						)
          ldm.to(snake_case_						)
          ldm.set_progress_bar_config(disable=snake_case_						)

          snake_case__  :    Tuple    						=      torch.manual_seed(0						)
          snake_case__  :    Dict    						=      ldm(generator=snake_case_ ,     num_inference_steps=5 ,     output_type="""numpy"""						).images

          snake_case__  :    str    						=      image[0, -3:, -3:, -1]

          assert image.shape == (1, 256, 256, 3)
          snake_case__  :    Optional[int]    						=      np.array([0.4399, 0.44975, 0.46825, 0.474, 0.4359, 0.4581, 0.45095, 0.4341, 0.4447]						)
          snake_case__  :    Optional[Any]    						=      1E-2 if torch_device != """mps""" else 3E-2

          assert np.abs(image_slice.flatten() - expected_slice						).max() < tolerance





'''simple docstring'''





import string
from math import logaa





def 						__snake_case(				_lowerCAmelCase     ,   _lowerCAmelCase		)		-> int:
      snake_case__  :    List[str]    						=      document.translate(
          str.maketrans(""""""     ,   """"""     ,   string.punctuation		)		).replace("""\n"""     ,   """"""		)
      snake_case__  :    List[str]    						=      document_without_punctuation.split(""" """		)  # word tokenization
      return len([word for word in tokenize_document if word.lower() == term.lower()]		)





def 						__snake_case(				_lowerCAmelCase     ,   _lowerCAmelCase		)		-> tuple[int, int]:
      snake_case__  :    Dict    						=      corpus.lower().translate(
          str.maketrans(""""""     ,   """"""     ,   string.punctuation		)		)  # strip all punctuation and replace it with ''
      snake_case__  :    Any    						=      corpus_without_punctuation.split("""\n"""		)
      snake_case__  :    int    						=      term.lower()
      return (len([doc for doc in docs if term in doc]		), len(_lowerCAmelCase		))





def 						__snake_case(				_lowerCAmelCase     ,   _lowerCAmelCase     ,   _lowerCAmelCase=False		)		-> float:
      if smoothing:
            if n == 0:
                  raise ValueError("""log10(0) is undefined."""		)
            return round(1 + logaa(n / (1 + df)		)     ,   3		)

      if df == 0:
            raise ZeroDivisionError("""df must be > 0"""		)
      elif n == 0:
            raise ValueError("""log10(0) is undefined."""		)
      return round(logaa(n / df		)     ,   3		)





def 						__snake_case(				_lowerCAmelCase     ,   _lowerCAmelCase		)		-> float:
      return round(tf * idf     ,   3		)
