



'''simple docstring'''





import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotSmallConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
   import os

   # The slow tests are often failing with OOM error on GPU
   # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
   # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
   _UpperCamelCase											=		'platform'

   import jax
   import jax.numpy as jnp

   from transformers.models.blenderbot_small.modeling_flax_blenderbot_small import (
       FlaxBlenderbotSmallForConditionalGeneration,
       FlaxBlenderbotSmallModel,
       shift_tokens_right,
   )

def 			a_	(				_lowerCAmelCase			,_lowerCAmelCase			,_lowerCAmelCase=None			,_lowerCAmelCase=None			,_lowerCAmelCase=None			,_lowerCAmelCase=None			,_lowerCAmelCase=None			,_lowerCAmelCase=None			,) -> Any:
  if attention_mask is None:
    __lowerCamelCase			:			List[Any]       			=					np.where(input_ids != config.pad_token_id			,1			,0			)
  if decoder_attention_mask is None:
    __lowerCamelCase			:			List[str]       			=					np.where(decoder_input_ids != config.pad_token_id			,1			,0			)
  if head_mask is None:
    __lowerCamelCase			:			Union[str, Any]       			=					np.ones((config.encoder_layers, config.encoder_attention_heads)			)
  if decoder_head_mask is None:
    __lowerCamelCase			:			List[Any]       			=					np.ones((config.decoder_layers, config.decoder_attention_heads)			)
  if cross_attn_head_mask is None:
    __lowerCamelCase			:			Optional[Any]       			=					np.ones((config.decoder_layers, config.decoder_attention_heads)			)
  return {
      "input_ids": input_ids,
      "decoder_input_ids": decoder_input_ids,
      "attention_mask": attention_mask,
      "decoder_attention_mask": attention_mask,
  }






class    lowerCamelCase_       :
  """simple docstring"""




  def __init__(					self :      Dict     ,      _a :      Optional[Any]     ,      _a :      List[str]=13     ,      _a :      Any=7     ,      _a :      List[str]=True     ,      _a :      str=False     ,      _a :      List[Any]=99     ,      _a :      List[str]=16     ,      _a :      str=2     ,      _a :      Optional[Any]=4     ,      _a :      Union[str, Any]=4     ,      _a :      List[Any]="gelu"     ,      _a :      int=0.1     ,      _a :      int=0.1     ,      _a :      Dict=32     ,      _a :      Union[str, Any]=2     ,      _a :      Tuple=1     ,      _a :      Any=0     ,      _a :      Tuple=0.02     ,      )   ->   int:
    __lowerCamelCase			:			Dict       			=					parent
    __lowerCamelCase			:			str       			=					batch_size
    __lowerCamelCase			:			int       			=					seq_length
    __lowerCamelCase			:			Union[str, Any]       			=					is_training
    __lowerCamelCase			:			List[str]       			=					use_labels
    __lowerCamelCase			:			Any       			=					vocab_size
    __lowerCamelCase			:			Dict       			=					hidden_size
    __lowerCamelCase			:			Tuple       			=					num_hidden_layers
    __lowerCamelCase			:			Union[str, Any]       			=					num_attention_heads
    __lowerCamelCase			:			Any       			=					intermediate_size
    __lowerCamelCase			:			Optional[Any]       			=					hidden_act
    __lowerCamelCase			:			Optional[int]       			=					hidden_dropout_prob
    __lowerCamelCase			:			str       			=					attention_probs_dropout_prob
    __lowerCamelCase			:			Any       			=					max_position_embeddings
    __lowerCamelCase			:			Any       			=					eos_token_id
    __lowerCamelCase			:			Optional[int]       			=					pad_token_id
    __lowerCamelCase			:			str       			=					bos_token_id
    __lowerCamelCase			:			Dict       			=					initializer_range




  def 		_lowercase	(					self :      Union[str, Any]  )   ->   Optional[int]:
    __lowerCamelCase			:			Optional[Any]       			=					np.clip(ids_tensor([self.batch_size, self.seq_length - 1]     ,      self.vocab_size  )     ,      3     ,      self.vocab_size  )
    __lowerCamelCase			:			Any       			=					np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)     ,      dtype=np.intaa  ))     ,      -1  )

    __lowerCamelCase			:			Optional[int]       			=					shift_tokens_right(_a     ,      1     ,      2  )

    __lowerCamelCase			:			Optional[int]       			=					BlenderbotSmallConfig(
        vocab_size=self.vocab_size     ,      d_model=self.hidden_size     ,      encoder_layers=self.num_hidden_layers     ,      decoder_layers=self.num_hidden_layers     ,      encoder_attention_heads=self.num_attention_heads     ,      decoder_attention_heads=self.num_attention_heads     ,      encoder_ffn_dim=self.intermediate_size     ,      decoder_ffn_dim=self.intermediate_size     ,      dropout=self.hidden_dropout_prob     ,      attention_dropout=self.attention_probs_dropout_prob     ,      max_position_embeddings=self.max_position_embeddings     ,      eos_token_id=self.eos_token_id     ,      bos_token_id=self.bos_token_id     ,      pad_token_id=self.pad_token_id     ,      initializer_range=self.initializer_range     ,      use_cache=_a     ,      )
    __lowerCamelCase			:			Any       			=					prepare_blenderbot_inputs_dict(_a     ,      _a     ,      _a  )
    return config, inputs_dict




  def 		_lowercase	(					self :      Dict  )   ->   List[Any]:
    __lowerCamelCase			,__lowerCamelCase			:			List[Any]       			=					self.prepare_config_and_inputs()
    return config, inputs_dict




  def 		_lowercase	(					self :      Optional[Any]     ,      _a :      Dict     ,      _a :      Dict     ,      _a :      Optional[int]  )   ->   int:
    __lowerCamelCase			:			int       			=					20
    __lowerCamelCase			:			Optional[int]       			=					model_class_name(_a  )

    __lowerCamelCase			:			List[Any]       			=					model.encode(inputs_dict['input_ids']  )

    __lowerCamelCase			,__lowerCamelCase			:			Optional[Any]       			=					(
        inputs_dict['decoder_input_ids'],
        inputs_dict['decoder_attention_mask'],
    )

    __lowerCamelCase			:			Tuple       			=					model.init_cache(decoder_input_ids.shape[0]     ,      _a     ,      _a  )
    __lowerCamelCase			:			List[Any]       			=					jnp.ones((decoder_input_ids.shape[0], max_decoder_length)     ,      dtype='i4'  )

    __lowerCamelCase			:			Any       			=					jnp.broadcast_to(
        jnp.arange(decoder_input_ids.shape[-1] - 1  )[None, :]     ,      (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)     ,      )
    __lowerCamelCase			:			int       			=					model.decode(
        decoder_input_ids[:, :-1]     ,      _a     ,      decoder_attention_mask=_a     ,      past_key_values=_a     ,      decoder_position_ids=_a     ,      )

    __lowerCamelCase			:			Any       			=					jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]     ,      dtype='i4'  )
    __lowerCamelCase			:			str       			=					model.decode(
        decoder_input_ids[:, -1:]     ,      _a     ,      decoder_attention_mask=_a     ,      past_key_values=outputs_cache.past_key_values     ,      decoder_position_ids=_a     ,      )

    __lowerCamelCase			:			Dict       			=					model.decode(_a     ,      _a  )

    __lowerCamelCase			:			List[str]       			=					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])  )  )
    self.parent.assertTrue(diff < 1e-3     ,      msg=f'Max diff is {diff}'  )




  def 		_lowercase	(					self :      Optional[int]     ,      _a :      List[str]     ,      _a :      str     ,      _a :      Dict  )   ->   List[Any]:
    __lowerCamelCase			:			List[str]       			=					20
    __lowerCamelCase			:			Tuple       			=					model_class_name(_a  )

    __lowerCamelCase			:			Dict       			=					model.encode(inputs_dict['input_ids']  )

    __lowerCamelCase			,__lowerCamelCase			:			Optional[int]       			=					(
        inputs_dict['decoder_input_ids'],
        inputs_dict['decoder_attention_mask'],
    )

    __lowerCamelCase			:			Optional[Any]       			=					jnp.concatenate(
        [
            decoder_attention_mask,
            jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])  ),
        ]     ,      axis=-1     ,      )

    __lowerCamelCase			:			Any       			=					model.init_cache(decoder_input_ids.shape[0]     ,      _a     ,      _a  )
    __lowerCamelCase			:			str       			=					jnp.broadcast_to(
        jnp.arange(decoder_input_ids.shape[-1] - 1  )[None, :]     ,      (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)     ,      )

    __lowerCamelCase			:			str       			=					model.decode(
        decoder_input_ids[:, :-1]     ,      _a     ,      decoder_attention_mask=_a     ,      past_key_values=_a     ,      decoder_position_ids=_a     ,      )
    __lowerCamelCase			:			str       			=					jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]     ,      dtype='i4'  )
    __lowerCamelCase			:			Tuple       			=					model.decode(
        decoder_input_ids[:, -1:]     ,      _a     ,      past_key_values=outputs_cache.past_key_values     ,      decoder_attention_mask=_a     ,      decoder_position_ids=_a     ,      )

    __lowerCamelCase			:			Union[str, Any]       			=					model.decode(_a     ,      _a     ,      decoder_attention_mask=_a  )

    __lowerCamelCase			:			List[str]       			=					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])  )  )
    self.parent.assertTrue(diff < 1e-3     ,      msg=f'Max diff is {diff}'  )






@require_flax
class    lowerCamelCase_       (							unittest.TestCase	):
  """simple docstring"""




  a_				   =99




  def 		_lowercase	(					self :      Dict  )   ->   Optional[int]:
    __lowerCamelCase			:			List[Any]       			=					np.array(
        [
            [71, 82, 18, 33, 46, 91, 2],
            [68, 34, 26, 58, 30, 82, 2],
            [5, 97, 17, 39, 94, 40, 2],
            [76, 83, 94, 25, 70, 78, 2],
            [87, 59, 41, 35, 48, 66, 2],
            [55, 13, 16, 58, 5, 2, 1],  # note padding
            [64, 27, 31, 51, 12, 75, 2],
            [52, 64, 86, 17, 83, 39, 2],
            [48, 61, 9, 24, 71, 82, 2],
            [26, 1, 60, 48, 22, 13, 2],
            [21, 5, 62, 28, 14, 76, 2],
            [45, 98, 37, 86, 59, 48, 2],
            [70, 70, 50, 9, 28, 0, 2],
        ]     ,      dtype=np.intaa     ,      )

    __lowerCamelCase			:			Any       			=					input_ids.shape[0]
    __lowerCamelCase			:			Optional[int]       			=					BlenderbotSmallConfig(
        vocab_size=self.vocab_size     ,      d_model=24     ,      encoder_layers=2     ,      decoder_layers=2     ,      encoder_attention_heads=2     ,      decoder_attention_heads=2     ,      encoder_ffn_dim=32     ,      decoder_ffn_dim=32     ,      max_position_embeddings=48     ,      eos_token_id=2     ,      pad_token_id=1     ,      bos_token_id=0     ,      )
    return config, input_ids, batch_size




  def 		_lowercase	(					self :      List[str]  )   ->   Optional[int]:
    __lowerCamelCase			,__lowerCamelCase			,__lowerCamelCase			:			List[Any]       			=					self._get_config_and_data()
    __lowerCamelCase			:			Optional[int]       			=					FlaxBlenderbotSmallForConditionalGeneration(_a  )
    __lowerCamelCase			:			Any       			=					lm_model(input_ids=_a  )
    __lowerCamelCase			:			int       			=					(batch_size, input_ids.shape[1], config.vocab_size)
    self.assertEqual(outputs['logits'].shape     ,      _a  )




  def 		_lowercase	(					self :      List[Any]  )   ->   Optional[Any]:
    __lowerCamelCase			:			str       			=					BlenderbotSmallConfig(
        vocab_size=self.vocab_size     ,      d_model=14     ,      encoder_layers=2     ,      decoder_layers=2     ,      encoder_attention_heads=2     ,      decoder_attention_heads=2     ,      encoder_ffn_dim=8     ,      decoder_ffn_dim=8     ,      max_position_embeddings=48     ,      )
    __lowerCamelCase			:			List[str]       			=					FlaxBlenderbotSmallForConditionalGeneration(_a  )
    __lowerCamelCase			:			str       			=					np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]     ,      dtype=np.intaa  )
    __lowerCamelCase			:			Tuple       			=					np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]     ,      dtype=np.intaa  )
    __lowerCamelCase			:			Union[str, Any]       			=					lm_model(input_ids=_a     ,      decoder_input_ids=_a  )
    __lowerCamelCase			:			Optional[Any]       			=					(*summary.shape, config.vocab_size)
    self.assertEqual(outputs['logits'].shape     ,      _a  )




  def 		_lowercase	(					self :      List[Any]  )   ->   Dict:
    __lowerCamelCase			:			Dict       			=					np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]     ,      dtype=np.intaa  )
    __lowerCamelCase			:			Tuple       			=					shift_tokens_right(_a     ,      1     ,      2  )
    __lowerCamelCase			:			str       			=					np.equal(_a     ,      1  ).astype(np.floataa  ).sum()
    __lowerCamelCase			:			Optional[Any]       			=					np.equal(_a     ,      1  ).astype(np.floataa  ).sum()
    self.assertEqual(shifted.shape     ,      input_ids.shape  )
    self.assertEqual(_a     ,      n_pad_before - 1  )
    self.assertTrue(np.equal(shifted[:, 0]     ,      2  ).all()  )






@require_flax
class    lowerCamelCase_       (							SCREAMING_SNAKE_CASE_  ,  unittest.TestCase  ,  SCREAMING_SNAKE_CASE_	):
  """simple docstring"""




  a_				   =True
  a_				   =(
      (
          FlaxBlenderbotSmallModel,
          FlaxBlenderbotSmallForConditionalGeneration,
      )
      if is_flax_available()
      else ()
  )
  a_				   =(FlaxBlenderbotSmallForConditionalGeneration,) if is_flax_available() else ()




  def 		_lowercase	(					self :      Optional[int]  )   ->   Optional[int]:
    __lowerCamelCase			:			Tuple       			=					FlaxBlenderbotSmallModelTester(self  )




  def 		_lowercase	(					self :      int  )   ->   Optional[Any]:
    __lowerCamelCase			,__lowerCamelCase			:			Tuple       			=					self.model_tester.prepare_config_and_inputs()
    for model_class in self.all_model_classes:
      self.model_tester.check_use_cache_forward(_a     ,      _a     ,      _a  )




  def 		_lowercase	(					self :      Tuple  )   ->   Union[str, Any]:
    __lowerCamelCase			,__lowerCamelCase			:			int       			=					self.model_tester.prepare_config_and_inputs()
    for model_class in self.all_model_classes:
      self.model_tester.check_use_cache_forward_with_attn_mask(_a     ,      _a     ,      _a  )




  def 		_lowercase	(					self :      str  )   ->   Any:
    __lowerCamelCase			,__lowerCamelCase			:			str       			=					self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
      with self.subTest(model_class.__name__  ):
        __lowerCamelCase			:			Tuple       			=					self._prepare_for_class(_a     ,      _a  )
        __lowerCamelCase			:			Optional[int]       			=					model_class(_a  )

        @jax.jit
        def encode_jitted(_a :      List[str]     ,      _a :      Optional[Any]=None     ,      **_a :      Optional[Any]  ):
          return model.encode(input_ids=_a     ,      attention_mask=_a  )

        with self.subTest('JIT Enabled'  ):
          __lowerCamelCase			:			Union[str, Any]       			=					encode_jitted(**_a  ).to_tuple()

        with self.subTest('JIT Disabled'  ):
          with jax.disable_jit():
            __lowerCamelCase			:			Optional[int]       			=					encode_jitted(**_a  ).to_tuple()

        self.assertEqual(len(_a  )     ,      len(_a  )  )
        for jitted_output, output in zip(_a     ,      _a  ):
          self.assertEqual(jitted_output.shape     ,      output.shape  )




  def 		_lowercase	(					self :      str  )   ->   str:
    __lowerCamelCase			,__lowerCamelCase			:			Dict       			=					self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
      with self.subTest(model_class.__name__  ):
        __lowerCamelCase			:			int       			=					model_class(_a  )
        __lowerCamelCase			:			int       			=					model.encode(inputs_dict['input_ids']     ,      inputs_dict['attention_mask']  )

        __lowerCamelCase			:			Tuple       			=					{
            'decoder_input_ids': inputs_dict['decoder_input_ids'],
            'decoder_attention_mask': inputs_dict['decoder_attention_mask'],
            'encoder_outputs': encoder_outputs,
        }

        @jax.jit
        def decode_jitted(_a :      List[str]     ,      _a :      List[Any]     ,      _a :      Union[str, Any]  ):
          return model.decode(
              decoder_input_ids=_a     ,      decoder_attention_mask=_a     ,      encoder_outputs=_a     ,      )

        with self.subTest('JIT Enabled'  ):
          __lowerCamelCase			:			Optional[Any]       			=					decode_jitted(**_a  ).to_tuple()

        with self.subTest('JIT Disabled'  ):
          with jax.disable_jit():
            __lowerCamelCase			:			Optional[int]       			=					decode_jitted(**_a  ).to_tuple()

        self.assertEqual(len(_a  )     ,      len(_a  )  )
        for jitted_output, output in zip(_a     ,      _a  ):
          self.assertEqual(jitted_output.shape     ,      output.shape  )




  @slow
  def 		_lowercase	(					self :      Union[str, Any]  )   ->   int:
    for model_class_name in self.all_model_classes:
      __lowerCamelCase			:			List[Any]       			=					model_class_name.from_pretrained('facebook/blenderbot_small-90M'  )
      # FlaxBlenderbotForSequenceClassification expects eos token in input_ids
      __lowerCamelCase			:			List[Any]       			=					np.ones((1, 1)  ) * model.config.eos_token_id
      __lowerCamelCase			:			Optional[Any]       			=					model(_a  )
      self.assertIsNotNone(_a  )











'''simple docstring'''





from typing import Callable, List, Optional, Union

import PIL
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPSegForImageSegmentation,
    CLIPSegProcessor,
    CLIPTextModel,
    CLIPTokenizer,
)

from diffusers import DiffusionPipeline
from diffusers.configuration_utils import FrozenDict
from diffusers.models import AutoencoderKL, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion import StableDiffusionInpaintPipeline
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import deprecate, is_accelerate_available, logging


_UpperCamelCase											=		logging.get_logger(__name__)  # pylint: disable=invalid-name






class    lowerCamelCase_       (							SCREAMING_SNAKE_CASE_	):
  """simple docstring"""




  def __init__(					self :      Union[str, Any]     ,      _a :      CLIPSegForImageSegmentation     ,      _a :      CLIPSegProcessor     ,      _a :      AutoencoderKL     ,      _a :      CLIPTextModel     ,      _a :      CLIPTokenizer     ,      _a :      UNetaDConditionModel     ,      _a :      Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]     ,      _a :      StableDiffusionSafetyChecker     ,      _a :      CLIPImageProcessor     ,      )   ->   int:
    super().__init__()

    if hasattr(scheduler.config     ,      'steps_offset'  ) and scheduler.config.steps_offset != 1:
      __lowerCamelCase			:			int       			=					(
          f'The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`'
          f' should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure '
          'to update the config accordingly as leaving `steps_offset` might led to incorrect results'
          ' in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,'
          ' it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`'
          ' file'
      )
      deprecate('steps_offset!=1'     ,      '1.0.0'     ,      _a     ,      standard_warn=_a  )
      __lowerCamelCase			:			int       			=					dict(scheduler.config  )
      __lowerCamelCase			:			Any       			=					1
      __lowerCamelCase			:			List[Any]       			=					FrozenDict(_a  )

    if hasattr(scheduler.config     ,      'skip_prk_steps'  ) and scheduler.config.skip_prk_steps is False:
      __lowerCamelCase			:			str       			=					(
          f'The configuration file of this scheduler: {scheduler} has not set the configuration'
          ' `skip_prk_steps`. `skip_prk_steps` should be set to True in the configuration file. Please make'
          ' sure to update the config accordingly as not setting `skip_prk_steps` in the config might lead to'
          ' incorrect results in future versions. If you have downloaded this checkpoint from the Hugging Face'
          ' Hub, it would be very nice if you could open a Pull request for the'
          ' `scheduler/scheduler_config.json` file'
      )
      deprecate('skip_prk_steps not set'     ,      '1.0.0'     ,      _a     ,      standard_warn=_a  )
      __lowerCamelCase			:			Dict       			=					dict(scheduler.config  )
      __lowerCamelCase			:			Tuple       			=					True
      __lowerCamelCase			:			Union[str, Any]       			=					FrozenDict(_a  )

    if safety_checker is None:
      logger.warning(
          f'You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure'
          ' that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered'
          ' results in services or applications open to the public. Both the diffusers team and Hugging Face'
          ' strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling'
          ' it only for use-cases that involve analyzing network behavior or auditing its results. For more'
          ' information, please have a look at https://github.com/huggingface/diffusers/pull/254 .'  )

    self.register_modules(
        segmentation_model=_a     ,      segmentation_processor=_a     ,      vae=_a     ,      text_encoder=_a     ,      tokenizer=_a     ,      unet=_a     ,      scheduler=_a     ,      safety_checker=_a     ,      feature_extractor=_a     ,      )




  def 		_lowercase	(					self :      Optional[int]     ,      _a :      Optional[Union[str, int]] = "auto"  )   ->   List[str]:
    if slice_size == "auto":
      # half the attention head size is usually a good trade-off between
      # speed and memory
      __lowerCamelCase			:			List[Any]       			=					self.unet.config.attention_head_dim // 2
    self.unet.set_attention_slice(_a  )




  def 		_lowercase	(					self :      Optional[Any]  )   ->   int:
    self.enable_attention_slicing(_a  )




  def 		_lowercase	(					self :      str  )   ->   Any:
    if is_accelerate_available():
      from accelerate import cpu_offload
    else:
      raise ImportError('Please install accelerate via `pip install accelerate`'  )

    __lowerCamelCase			:			Dict       			=					torch.device('cuda'  )

    for cpu_offloaded_model in [self.unet, self.text_encoder, self.vae, self.safety_checker]:
      if cpu_offloaded_model is not None:
        cpu_offload(_a     ,      _a  )




  @property
  # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
  def 		_lowercase	(					self :      Dict  )   ->   int:
    if self.device != torch.device('meta'  ) or not hasattr(self.unet     ,      '_hf_hook'  ):
      return self.device
    for module in self.unet.modules():
      if (
          hasattr(_a     ,      '_hf_hook'  )
          and hasattr(module._hf_hook     ,      'execution_device'  )
          and module._hf_hook.execution_device is not None
      ):
        return torch.device(module._hf_hook.execution_device  )
    return self.device




  @torch.no_grad()
  def __call__(					self :      List[str]     ,      _a :      Union[str, List[str]]     ,      _a :      Union[torch.FloatTensor, PIL.Image.Image]     ,      _a :      str     ,      _a :      int = 512     ,      _a :      int = 512     ,      _a :      int = 50     ,      _a :      float = 7.5     ,      _a :      Optional[Union[str, List[str]]] = None     ,      _a :      Optional[int] = 1     ,      _a :      float = 0.0     ,      _a :      Optional[torch.Generator] = None     ,      _a :      Optional[torch.FloatTensor] = None     ,      _a :      Optional[str] = "pil"     ,      _a :      bool = True     ,      _a :      Optional[Callable[[int, int, torch.FloatTensor], None]] = None     ,      _a :      int = 1     ,      **_a :      Optional[Any]     ,      )   ->   int:
    __lowerCamelCase			:			Union[str, Any]       			=					self.segmentation_processor(
        text=[text]     ,      images=[image]     ,      padding='max_length'     ,      return_tensors='pt'  ).to(self.device  )
    __lowerCamelCase			:			Union[str, Any]       			=					self.segmentation_model(**_a  )
    __lowerCamelCase			:			List[str]       			=					torch.sigmoid(outputs.logits  ).cpu().detach().unsqueeze(-1  ).numpy()
    __lowerCamelCase			:			Optional[Any]       			=					self.numpy_to_pil(_a  )[0].resize(image.size  )

    # Run inpainting pipeline with the generated mask
    __lowerCamelCase			:			Tuple       			=					StableDiffusionInpaintPipeline(
        vae=self.vae     ,      text_encoder=self.text_encoder     ,      tokenizer=self.tokenizer     ,      unet=self.unet     ,      scheduler=self.scheduler     ,      safety_checker=self.safety_checker     ,      feature_extractor=self.feature_extractor     ,      )
    return inpainting_pipeline(
        prompt=_a     ,      image=_a     ,      mask_image=_a     ,      height=_a     ,      width=_a     ,      num_inference_steps=_a     ,      guidance_scale=_a     ,      negative_prompt=_a     ,      num_images_per_prompt=_a     ,      eta=_a     ,      generator=_a     ,      latents=_a     ,      output_type=_a     ,      return_dict=_a     ,      callback=_a     ,      callback_steps=_a     ,      )






