

'''simple docstring'''

import os
import tempfile
import unittest
from pathlib import Path

from transformers import AutoConfig, is_torch_available
from transformers.testing_utils import require_torch, torch_device


if is_torch_available():
       from transformers import PyTorchBenchmark, PyTorchBenchmarkArguments


@require_torch
class      lowerCAmelCase   (					unittest.TestCase      ):







       def 	snake_case      (							self	:       Union[str, Any]  ,					__lowercase	:       List[Any]					):







            """simple docstring"""







            for model_result in results.values():
                 for batch_size, sequence_length in zip(model_result['bs']  ,					model_result['ss']					):
                      __lowercase							=model_result['result'][batch_size][sequence_length]
                      self.assertIsNotNone(snake_case_					)







       def 	snake_case      (							self	:       Optional[int]					):







            """simple docstring"""







            __lowercase							='sshleifer/tiny-gpt2'
            __lowercase							=PyTorchBenchmarkArguments(
                models=[MODEL_ID]  ,					training=snake_case_  ,					inference=snake_case_  ,					sequence_lengths=[8]  ,					batch_sizes=[1]  ,					multi_process=snake_case_  ,					)
            __lowercase							=PyTorchBenchmark(snake_case_					)
            __lowercase							=benchmark.run()
            self.check_results_dict_not_empty(results.time_inference_result					)
            self.check_results_dict_not_empty(results.memory_inference_result					)







       def 	snake_case      (							self	:       Optional[int]					):







            """simple docstring"""







            __lowercase							='sgugger/tiny-distilbert-classification'
            __lowercase							=PyTorchBenchmarkArguments(
                models=[MODEL_ID]  ,					training=snake_case_  ,					inference=snake_case_  ,					sequence_lengths=[8]  ,					batch_sizes=[1]  ,					multi_process=snake_case_  ,					only_pretrain_model=snake_case_  ,					)
            __lowercase							=PyTorchBenchmark(snake_case_					)
            __lowercase							=benchmark.run()
            self.check_results_dict_not_empty(results.time_inference_result					)
            self.check_results_dict_not_empty(results.memory_inference_result					)







       def 	snake_case      (							self	:       str					):







            """simple docstring"""







            __lowercase							='sshleifer/tiny-gpt2'
            __lowercase							=PyTorchBenchmarkArguments(
                models=[MODEL_ID]  ,					training=snake_case_  ,					inference=snake_case_  ,					torchscript=snake_case_  ,					sequence_lengths=[8]  ,					batch_sizes=[1]  ,					multi_process=snake_case_  ,					)
            __lowercase							=PyTorchBenchmark(snake_case_					)
            __lowercase							=benchmark.run()
            self.check_results_dict_not_empty(results.time_inference_result					)
            self.check_results_dict_not_empty(results.memory_inference_result					)







       @unittest.skipIf(torch_device == 'cpu'  ,					'Cant do half precision'					)
       def 	snake_case      (							self	:       str					):







            """simple docstring"""







            __lowercase							='sshleifer/tiny-gpt2'
            __lowercase							=PyTorchBenchmarkArguments(
                models=[MODEL_ID]  ,					training=snake_case_  ,					inference=snake_case_  ,					fpaa=snake_case_  ,					sequence_lengths=[8]  ,					batch_sizes=[1]  ,					multi_process=snake_case_  ,					)
            __lowercase							=PyTorchBenchmark(snake_case_					)
            __lowercase							=benchmark.run()
            self.check_results_dict_not_empty(results.time_inference_result					)
            self.check_results_dict_not_empty(results.memory_inference_result					)







       def 	snake_case      (							self	:       Tuple					):







            """simple docstring"""







            __lowercase							='sshleifer/tiny-gpt2'
            __lowercase							=AutoConfig.from_pretrained(snake_case_					)
            # set architectures equal to `None`
            __lowercase							=None
            __lowercase							=PyTorchBenchmarkArguments(
                models=[MODEL_ID]  ,					training=snake_case_  ,					inference=snake_case_  ,					sequence_lengths=[8]  ,					batch_sizes=[1]  ,					multi_process=snake_case_  ,					)
            __lowercase							=PyTorchBenchmark(snake_case_  ,					configs=[config]					)
            __lowercase							=benchmark.run()
            self.check_results_dict_not_empty(results.time_inference_result					)
            self.check_results_dict_not_empty(results.memory_inference_result					)







       def 	snake_case      (							self	:       List[str]					):







            """simple docstring"""







            __lowercase							='sshleifer/tiny-gpt2'
            __lowercase							=PyTorchBenchmarkArguments(
                models=[MODEL_ID]  ,					training=snake_case_  ,					inference=snake_case_  ,					sequence_lengths=[8]  ,					batch_sizes=[1]  ,					multi_process=snake_case_  ,					)
            __lowercase							=PyTorchBenchmark(snake_case_					)
            __lowercase							=benchmark.run()
            self.check_results_dict_not_empty(results.time_train_result					)
            self.check_results_dict_not_empty(results.memory_train_result					)







       @unittest.skipIf(torch_device == 'cpu'  ,					'Can\'t do half precision'					)
       def 	snake_case      (							self	:       int					):







            """simple docstring"""







            __lowercase							='sshleifer/tiny-gpt2'
            __lowercase							=PyTorchBenchmarkArguments(
                models=[MODEL_ID]  ,					training=snake_case_  ,					inference=snake_case_  ,					sequence_lengths=[8]  ,					batch_sizes=[1]  ,					fpaa=snake_case_  ,					multi_process=snake_case_  ,					)
            __lowercase							=PyTorchBenchmark(snake_case_					)
            __lowercase							=benchmark.run()
            self.check_results_dict_not_empty(results.time_train_result					)
            self.check_results_dict_not_empty(results.memory_train_result					)







       def 	snake_case      (							self	:       int					):







            """simple docstring"""







            __lowercase							='sshleifer/tiny-gpt2'
            __lowercase							=AutoConfig.from_pretrained(snake_case_					)
            __lowercase							=PyTorchBenchmarkArguments(
                models=[MODEL_ID]  ,					training=snake_case_  ,					inference=snake_case_  ,					sequence_lengths=[8]  ,					batch_sizes=[1]  ,					multi_process=snake_case_  ,					)
            __lowercase							=PyTorchBenchmark(snake_case_  ,					configs=[config]					)
            __lowercase							=benchmark.run()
            self.check_results_dict_not_empty(results.time_inference_result					)
            self.check_results_dict_not_empty(results.memory_inference_result					)







       def 	snake_case      (							self	:       Optional[int]					):







            """simple docstring"""







            __lowercase							='sshleifer/tinier_bart'
            __lowercase							=AutoConfig.from_pretrained(snake_case_					)
            __lowercase							=PyTorchBenchmarkArguments(
                models=[MODEL_ID]  ,					training=snake_case_  ,					inference=snake_case_  ,					sequence_lengths=[8]  ,					batch_sizes=[1]  ,					multi_process=snake_case_  ,					)
            __lowercase							=PyTorchBenchmark(snake_case_  ,					configs=[config]					)
            __lowercase							=benchmark.run()
            self.check_results_dict_not_empty(results.time_inference_result					)
            self.check_results_dict_not_empty(results.memory_inference_result					)







       def 	snake_case      (							self	:       Any					):







            """simple docstring"""







            __lowercase							='sshleifer/tiny-gpt2'
            __lowercase							=AutoConfig.from_pretrained(snake_case_					)
            __lowercase							=PyTorchBenchmarkArguments(
                models=[MODEL_ID]  ,					training=snake_case_  ,					inference=snake_case_  ,					sequence_lengths=[8]  ,					batch_sizes=[1]  ,					multi_process=snake_case_  ,					)
            __lowercase							=PyTorchBenchmark(snake_case_  ,					configs=[config]					)
            __lowercase							=benchmark.run()
            self.check_results_dict_not_empty(results.time_train_result					)
            self.check_results_dict_not_empty(results.memory_train_result					)







       def 	snake_case      (							self	:       List[str]					):







            """simple docstring"""







            __lowercase							='sshleifer/tinier_bart'
            __lowercase							=AutoConfig.from_pretrained(snake_case_					)
            __lowercase							=PyTorchBenchmarkArguments(
                models=[MODEL_ID]  ,					training=snake_case_  ,					inference=snake_case_  ,					sequence_lengths=[8]  ,					batch_sizes=[1]  ,					multi_process=snake_case_  ,					)
            __lowercase							=PyTorchBenchmark(snake_case_  ,					configs=[config]					)
            __lowercase							=benchmark.run()
            self.check_results_dict_not_empty(results.time_train_result					)
            self.check_results_dict_not_empty(results.memory_train_result					)







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







            """simple docstring"""







            __lowercase							='sshleifer/tiny-gpt2'
            with tempfile.TemporaryDirectory() as tmp_dir:
                 __lowercase							=PyTorchBenchmarkArguments(
                     models=[MODEL_ID]  ,					training=snake_case_  ,					inference=snake_case_  ,					save_to_csv=snake_case_  ,					sequence_lengths=[8]  ,					batch_sizes=[1]  ,					inference_time_csv_file=os.path.join(snake_case_  ,					'inf_time.csv'					)  ,					train_memory_csv_file=os.path.join(snake_case_  ,					'train_mem.csv'					)  ,					inference_memory_csv_file=os.path.join(snake_case_  ,					'inf_mem.csv'					)  ,					train_time_csv_file=os.path.join(snake_case_  ,					'train_time.csv'					)  ,					env_info_csv_file=os.path.join(snake_case_  ,					'env.csv'					)  ,					multi_process=snake_case_  ,					)
                 __lowercase							=PyTorchBenchmark(snake_case_					)
                 benchmark.run()
                 self.assertTrue(Path(os.path.join(snake_case_  ,					'inf_time.csv'					)					).exists()					)
                 self.assertTrue(Path(os.path.join(snake_case_  ,					'train_time.csv'					)					).exists()					)
                 self.assertTrue(Path(os.path.join(snake_case_  ,					'inf_mem.csv'					)					).exists()					)
                 self.assertTrue(Path(os.path.join(snake_case_  ,					'train_mem.csv'					)					).exists()					)
                 self.assertTrue(Path(os.path.join(snake_case_  ,					'env.csv'					)					).exists()					)







       def 	snake_case      (							self	:       List[Any]					):







            """simple docstring"""







            __lowercase							='sshleifer/tiny-gpt2'

            def _check_summary_is_not_empty(__lowercase	:       Any					):
                 self.assertTrue(hasattr(snake_case_  ,					'sequential'					)					)
                 self.assertTrue(hasattr(snake_case_  ,					'cumulative'					)					)
                 self.assertTrue(hasattr(snake_case_  ,					'current'					)					)
                 self.assertTrue(hasattr(snake_case_  ,					'total'					)					)

            with tempfile.TemporaryDirectory() as tmp_dir:
                 __lowercase							=PyTorchBenchmarkArguments(
                     models=[MODEL_ID]  ,					training=snake_case_  ,					inference=snake_case_  ,					sequence_lengths=[8]  ,					batch_sizes=[1]  ,					log_filename=os.path.join(snake_case_  ,					'log.txt'					)  ,					log_print=snake_case_  ,					trace_memory_line_by_line=snake_case_  ,					multi_process=snake_case_  ,					)
                 __lowercase							=PyTorchBenchmark(snake_case_					)
                 __lowercase							=benchmark.run()
                 _check_summary_is_not_empty(result.inference_summary					)
                 _check_summary_is_not_empty(result.train_summary					)
                 self.assertTrue(Path(os.path.join(snake_case_  ,					'log.txt'					)					).exists()					)









'''simple docstring'''




__SCREAMING_SNAKE_CASE     :List[str]       =				'''0.18.2'''

from .configuration_utils import ConfigMixin
from .utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_onnx_available,
    is_scipy_available,
    is_torch_available,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    logging,
)


try:
  if not is_onnx_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from .utils.dummy_onnx_objects import *  # noqa F403
else:
  from .pipelines import OnnxRuntimeModel

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from .utils.dummy_pt_objects import *  # noqa F403
else:
  from .models import (
      AutoencoderKL,
      ControlNetModel,
      ModelMixin,
      PriorTransformer,
      TaFilmDecoder,
      TransformeraDModel,
      UNetaDModel,
      UNetaDConditionModel,
      UNetaDModel,
      UNetaDConditionModel,
      VQModel,
  )
  from .optimization import (
      get_constant_schedule,
      get_constant_schedule_with_warmup,
      get_cosine_schedule_with_warmup,
      get_cosine_with_hard_restarts_schedule_with_warmup,
      get_linear_schedule_with_warmup,
      get_polynomial_decay_schedule_with_warmup,
      get_scheduler,
  )
  from .pipelines import (
      AudioPipelineOutput,
      ConsistencyModelPipeline,
      DanceDiffusionPipeline,
      DDIMPipeline,
      DDPMPipeline,
      DiffusionPipeline,
      DiTPipeline,
      ImagePipelineOutput,
      KarrasVePipeline,
      LDMPipeline,
      LDMSuperResolutionPipeline,
      PNDMPipeline,
      RePaintPipeline,
      ScoreSdeVePipeline,
  )
  from .schedulers import (
      CMStochasticIterativeScheduler,
      DDIMInverseScheduler,
      DDIMParallelScheduler,
      DDIMScheduler,
      DDPMParallelScheduler,
      DDPMScheduler,
      DEISMultistepScheduler,
      DPMSolverMultistepInverseScheduler,
      DPMSolverMultistepScheduler,
      DPMSolverSinglestepScheduler,
      EulerAncestralDiscreteScheduler,
      EulerDiscreteScheduler,
      HeunDiscreteScheduler,
      IPNDMScheduler,
      KarrasVeScheduler,
      KDPMaAncestralDiscreteScheduler,
      KDPMaDiscreteScheduler,
      PNDMScheduler,
      RePaintScheduler,
      SchedulerMixin,
      ScoreSdeVeScheduler,
      UnCLIPScheduler,
      UniPCMultistepScheduler,
      VQDiffusionScheduler,
  )
  from .training_utils import EMAModel

try:
  if not (is_torch_available() and is_scipy_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from .utils.dummy_torch_and_scipy_objects import *  # noqa F403
else:
  from .schedulers import LMSDiscreteScheduler

try:
  if not (is_torch_available() and is_torchsde_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from .utils.dummy_torch_and_torchsde_objects import *  # noqa F403
else:
  from .schedulers import DPMSolverSDEScheduler

try:
  if not (is_torch_available() and is_transformers_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from .utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
  from .pipelines import (
      AltDiffusionImgaImgPipeline,
      AltDiffusionPipeline,
      AudioLDMPipeline,
      CycleDiffusionPipeline,
      IFImgaImgPipeline,
      IFImgaImgSuperResolutionPipeline,
      IFInpaintingPipeline,
      IFInpaintingSuperResolutionPipeline,
      IFPipeline,
      IFSuperResolutionPipeline,
      ImageTextPipelineOutput,
      KandinskyImgaImgPipeline,
      KandinskyInpaintPipeline,
      KandinskyPipeline,
      KandinskyPriorPipeline,
      KandinskyVaaControlnetImgaImgPipeline,
      KandinskyVaaControlnetPipeline,
      KandinskyVaaImgaImgPipeline,
      KandinskyVaaInpaintPipeline,
      KandinskyVaaPipeline,
      KandinskyVaaPriorEmbaEmbPipeline,
      KandinskyVaaPriorPipeline,
      LDMTextToImagePipeline,
      PaintByExamplePipeline,
      SemanticStableDiffusionPipeline,
      ShapEImgaImgPipeline,
      ShapEPipeline,
      StableDiffusionAttendAndExcitePipeline,
      StableDiffusionControlNetImgaImgPipeline,
      StableDiffusionControlNetInpaintPipeline,
      StableDiffusionControlNetPipeline,
      StableDiffusionDepthaImgPipeline,
      StableDiffusionDiffEditPipeline,
      StableDiffusionImageVariationPipeline,
      StableDiffusionImgaImgPipeline,
      StableDiffusionInpaintPipeline,
      StableDiffusionInpaintPipelineLegacy,
      StableDiffusionInstructPixaPixPipeline,
      StableDiffusionLatentUpscalePipeline,
      StableDiffusionLDMaDPipeline,
      StableDiffusionModelEditingPipeline,
      StableDiffusionPanoramaPipeline,
      StableDiffusionParadigmsPipeline,
      StableDiffusionPipeline,
      StableDiffusionPipelineSafe,
      StableDiffusionPixaPixZeroPipeline,
      StableDiffusionSAGPipeline,
      StableDiffusionUpscalePipeline,
      StableUnCLIPImgaImgPipeline,
      StableUnCLIPPipeline,
      TextToVideoSDPipeline,
      TextToVideoZeroPipeline,
      UnCLIPImageVariationPipeline,
      UnCLIPPipeline,
      UniDiffuserModel,
      UniDiffuserPipeline,
      UniDiffuserTextDecoder,
      VersatileDiffusionDualGuidedPipeline,
      VersatileDiffusionImageVariationPipeline,
      VersatileDiffusionPipeline,
      VersatileDiffusionTextToImagePipeline,
      VideoToVideoSDPipeline,
      VQDiffusionPipeline,
  )

try:
  if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import *  # noqa F403
else:
  from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline

try:
  if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
  from .pipelines import StableDiffusionKDiffusionPipeline

try:
  if not (is_torch_available() and is_transformers_available() and is_onnx_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from .utils.dummy_torch_and_transformers_and_onnx_objects import *  # noqa F403
else:
  from .pipelines import (
      OnnxStableDiffusionImgaImgPipeline,
      OnnxStableDiffusionInpaintPipeline,
      OnnxStableDiffusionInpaintPipelineLegacy,
      OnnxStableDiffusionPipeline,
      OnnxStableDiffusionUpscalePipeline,
      StableDiffusionOnnxPipeline,
  )

try:
  if not (is_torch_available() and is_librosa_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from .utils.dummy_torch_and_librosa_objects import *  # noqa F403
else:
  from .pipelines import AudioDiffusionPipeline, Mel

try:
  if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from .utils.dummy_transformers_and_torch_and_note_seq_objects import *  # noqa F403
else:
  from .pipelines import SpectrogramDiffusionPipeline

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from .utils.dummy_flax_objects import *  # noqa F403
else:
  from .models.controlnet_flax import FlaxControlNetModel
  from .models.modeling_flax_utils import FlaxModelMixin
  from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel
  from .models.vae_flax import FlaxAutoencoderKL
  from .pipelines import FlaxDiffusionPipeline
  from .schedulers import (
      FlaxDDIMScheduler,
      FlaxDDPMScheduler,
      FlaxDPMSolverMultistepScheduler,
      FlaxKarrasVeScheduler,
      FlaxLMSDiscreteScheduler,
      FlaxPNDMScheduler,
      FlaxSchedulerMixin,
      FlaxScoreSdeVeScheduler,
  )


try:
  if not (is_flax_available() and is_transformers_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from .utils.dummy_flax_and_transformers_objects import *  # noqa F403
else:
  from .pipelines import (
      FlaxStableDiffusionControlNetPipeline,
      FlaxStableDiffusionImgaImgPipeline,
      FlaxStableDiffusionInpaintPipeline,
      FlaxStableDiffusionPipeline,
  )

try:
  if not (is_note_seq_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from .utils.dummy_note_seq_objects import *  # noqa F403
else:
  from .pipelines import MidiProcessor




