

'''simple docstring'''
from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_tf_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_tf_available():
     import tensorflow as tf


lowerCamelCase :      Optional[Any]					 =     logging.get_logger(__name__)







@dataclass
class 							A__    (       A__  ):
  A__		 =				[
      'no_inference',
      'no_cuda',
      'no_tpu',
      'no_speed',
      'no_memory',
      'no_env_print',
      'no_multi_process',
  ]





  def __init__(		self      :	List[Any]							,					**_a      :	Any )	->    Tuple:





       '''simple docstring'''






       for deprecated_arg in self.deprecated_args:
            if deprecated_arg in kwargs:
                 _SCREAMING_SNAKE_CASE							    =deprecated_arg[3:]
                 _SCREAMING_SNAKE_CASE							    =not kwargs.pop(_a )
                 logger.warning(
                     f"{deprecated_arg} is depreciated. Please use --no-{positive_arg} or"
                     f" {positive_arg}={kwargs[positive_arg]}" )
       _SCREAMING_SNAKE_CASE							    =kwargs.pop('tpu_name'							,					self.tpu_name )
       _SCREAMING_SNAKE_CASE							    =kwargs.pop('device_idx'							,					self.device_idx )
       _SCREAMING_SNAKE_CASE							    =kwargs.pop('eager_mode'							,					self.eager_mode )
       _SCREAMING_SNAKE_CASE							    =kwargs.pop('use_xla'							,					self.use_xla )
       super().__init__(**_a )

  A__		 =				field(
      default=A__     ,   metadata={'help': 'Name of TPU'}     ,   )
  A__		 =				field(
      default=0     ,   metadata={'help': 'CPU / GPU device index. Defaults to 0.'}     ,   )
  A__		 =				field(default=A__     ,   metadata={'help': 'Benchmark models in eager model.'}  )
  A__		 =				field(
      default=A__     ,   metadata={
          'help': 'Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`.'
      }     ,   )





  @cached_property
  def 						A  (		self      :	int )	->    Tuple["tf.distribute.cluster_resolver.TPUClusterResolver"]:





       '''simple docstring'''






       requires_backends(self							,					['tf'] )
       _SCREAMING_SNAKE_CASE							    =None
       if self.tpu:
            try:
                 if self.tpu_name:
                      _SCREAMING_SNAKE_CASE							    =tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name )
                 else:
                      _SCREAMING_SNAKE_CASE							    =tf.distribute.cluster_resolver.TPUClusterResolver()
            except ValueError:
                 _SCREAMING_SNAKE_CASE							    =None
       return tpu





  @cached_property
  def 						A  (		self      :	Union[str, Any] )	->    Tuple["tf.distribute.Strategy", "tf.distribute.cluster_resolver.TPUClusterResolver"]:





       '''simple docstring'''






       requires_backends(self							,					['tf'] )
       if self.is_tpu:
            tf.config.experimental_connect_to_cluster(self._setup_tpu )
            tf.tpu.experimental.initialize_tpu_system(self._setup_tpu )

            _SCREAMING_SNAKE_CASE							    =tf.distribute.TPUStrategy(self._setup_tpu )
       else:
            # currently no multi gpu is allowed
            if self.is_gpu:
                 # TODO: Currently only single GPU is supported
                 tf.config.set_visible_devices(self.gpu_list[self.device_idx]							,					'GPU' )
                 _SCREAMING_SNAKE_CASE							    =tf.distribute.OneDeviceStrategy(device=f"/gpu:{self.device_idx}" )
            else:
                 tf.config.set_visible_devices([]							,					'GPU' )  # disable GPU
                 _SCREAMING_SNAKE_CASE							    =tf.distribute.OneDeviceStrategy(device=f"/cpu:{self.device_idx}" )

       return strategy





  @property
  def 						A  (		self      :	List[str] )	->    bool:





       '''simple docstring'''






       requires_backends(self							,					['tf'] )
       return self._setup_tpu is not None





  @property
  def 						A  (		self      :	str )	->    "tf.distribute.Strategy":





       '''simple docstring'''






       requires_backends(self							,					['tf'] )
       return self._setup_strategy





  @property
  def 						A  (		self      :	Optional[int] )	->    Tuple:





       '''simple docstring'''






       requires_backends(self							,					['tf'] )
       return tf.config.list_physical_devices('GPU' )





  @property
  def 						A  (		self      :	str )	->    int:





       '''simple docstring'''






       requires_backends(self							,					['tf'] )
       if self.cuda:
            return len(self.gpu_list )
       return 0





  @property
  def 						A  (		self      :	Union[str, Any] )	->    bool:





       '''simple docstring'''






       return self.n_gpu > 0



'''simple docstring'''
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionImageVariationPipeline
from diffusers.utils.testing_utils import load_image, require_torch_gpu, slow, torch_device


lowerCamelCase :      Optional[int]					 =     False







class 							A__    (       unittest.TestCase  ):
  pass







@slow
@require_torch_gpu
class 							A__    (       unittest.TestCase  ):





  def 						A  (		self      :	Tuple )	->    Dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =VersatileDiffusionImageVariationPipeline.from_pretrained('shi-labs/versatile-diffusion' )
       pipe.to(_a )
       pipe.set_progress_bar_config(disable=_a )

       _SCREAMING_SNAKE_CASE							    =load_image(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
       _SCREAMING_SNAKE_CASE							    =torch.manual_seed(0 )
       _SCREAMING_SNAKE_CASE							    =pipe(
           image=_a							,					generator=_a							,					guidance_scale=7.5							,					num_inference_steps=50							,					output_type='numpy'							,					).images

       _SCREAMING_SNAKE_CASE							    =image[0, 253:256, 253:256, -1]

       assert image.shape == (1, 512, 512, 3)
       _SCREAMING_SNAKE_CASE							    =np.array([0.04_41, 0.04_69, 0.05_07, 0.05_75, 0.06_32, 0.06_50, 0.08_65, 0.09_09, 0.09_45] )

       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
