"""simple docstring"""





_UpperCamelCase   :						str      =    frozenset(
    [
        "prompt",
        "height",
        "width",
        "guidance_scale",
        "negative_prompt",
        "prompt_embeds",
        "negative_prompt_embeds",
        "cross_attention_kwargs",
    ]
)

_UpperCamelCase   :						int      =    frozenset(["prompt", "negative_prompt"])

_UpperCamelCase   :						str      =    frozenset([])

_UpperCamelCase   :						List[str]      =    frozenset(["image"])

_UpperCamelCase   :						str      =    frozenset(
    [
        "image",
        "height",
        "width",
        "guidance_scale",
    ]
)

_UpperCamelCase   :						int      =    frozenset(["image"])

_UpperCamelCase   :						Optional[Any]      =    frozenset(
    [
        "prompt",
        "image",
        "height",
        "width",
        "guidance_scale",
        "negative_prompt",
        "prompt_embeds",
        "negative_prompt_embeds",
    ]
)

_UpperCamelCase   :						int      =    frozenset(["prompt", "image", "negative_prompt"])

_UpperCamelCase   :						Optional[int]      =    frozenset(
    [
        # Text guided image variation with an image mask
        "prompt",
        "image",
        "mask_image",
        "height",
        "width",
        "guidance_scale",
        "negative_prompt",
        "prompt_embeds",
        "negative_prompt_embeds",
    ]
)

_UpperCamelCase   :						Tuple      =    frozenset(["prompt", "image", "mask_image", "negative_prompt"])

_UpperCamelCase   :						Tuple      =    frozenset(
    [
        # image variation with an image mask
        "image",
        "mask_image",
        "height",
        "width",
        "guidance_scale",
    ]
)

_UpperCamelCase   :						List[str]      =    frozenset(["image", "mask_image"])

_UpperCamelCase   :						Union[str, Any]      =    frozenset(
    [
        "example_image",
        "image",
        "mask_image",
        "height",
        "width",
        "guidance_scale",
    ]
)

_UpperCamelCase   :						Union[str, Any]      =    frozenset(["example_image", "image", "mask_image"])

_UpperCamelCase   :						int      =    frozenset(["class_labels"])

_UpperCamelCase   :						List[str]      =    frozenset(["class_labels"])

_UpperCamelCase   :						int      =    frozenset(["batch_size"])

_UpperCamelCase   :						Tuple      =    frozenset([])

_UpperCamelCase   :						List[Any]      =    frozenset(["batch_size"])

_UpperCamelCase   :						List[Any]      =    frozenset([])

_UpperCamelCase   :						Tuple      =    frozenset(
    [
        "prompt",
        "audio_length_in_s",
        "guidance_scale",
        "negative_prompt",
        "prompt_embeds",
        "negative_prompt_embeds",
        "cross_attention_kwargs",
    ]
)

_UpperCamelCase   :						Any      =    frozenset(["prompt", "negative_prompt"])
_UpperCamelCase   :						Union[str, Any]      =    frozenset(["input_tokens"])

_UpperCamelCase   :						List[Any]      =    frozenset(["input_tokens"])






'''simple docstring'''





import numpy as np

from transformers import Pipeline





def 						__snake_case(				_lowerCAmelCase		)		-> Optional[int]:
      snake_case__  :    Optional[Any]    						=      np.max(_lowerCAmelCase     ,   axis=-1     ,   keepdims=_lowerCAmelCase		)
      snake_case__  :    List[str]    						=      np.exp(outputs - maxes		)
      return shifted_exp / shifted_exp.sum(axis=-1     ,   keepdims=_lowerCAmelCase		)







class     UpperCAmelCase_       (       _a	):
    """simple docstring"""







    def lowerCamelCase       (    self					:     Optional[Any] ,     **snake_case_					:     int						):
          snake_case__  :    Optional[int]    						=      {}
          if "second_text" in kwargs:
                snake_case__  :    Union[str, Any]    						=      kwargs["""second_text"""]
          return preprocess_kwargs, {}, {}




    def lowerCamelCase       (    self					:     str ,     snake_case_					:     Tuple ,     snake_case_					:     Union[str, Any]=None						):
          return self.tokenizer(snake_case_ ,     text_pair=snake_case_ ,     return_tensors=self.framework						)




    def lowerCamelCase       (    self					:     List[Any] ,     snake_case_					:     Dict						):
          return self.model(**snake_case_						)




    def lowerCamelCase       (    self					:     int ,     snake_case_					:     List[Any]						):
          snake_case__  :    Union[str, Any]    						=      model_outputs.logits[0].numpy()
          snake_case__  :    List[str]    						=      softmax(snake_case_						)

          snake_case__  :    List[str]    						=      np.argmax(snake_case_						)
          snake_case__  :    List[str]    						=      self.model.config.idalabel[best_class]
          snake_case__  :    Optional[int]    						=      probabilities[best_class].item()
          snake_case__  :    str    						=      logits.tolist()
          return {"label": label, "score": score, "logits": logits}
