






"""simple docstring"""






from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
					from PIL import Image

					from ..image_utils import load_image

if is_tf_available():
					import tensorflow as tf

					from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
					from ..tf_utils import stable_softmax

if is_torch_available():
					from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING

SCREAMING_SNAKE_CASE						:						str					   =       logging.get_logger(__name__)





@add_end_docstrings(_lowerCamelCase       )
class       snake_case_       (    _lowerCamelCase       ):



	"""simple docstring"""

	def __init__(      self  ,					*__a  ,					**__a						):


					"""simple docstring"""

					super().__init__(*__a  ,					**__a						)
					requires_backends(self  ,					'vision'						)
					self.check_model_type(
					    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
					    if self.framework == 'tf'
					    else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING						)


	def       _UpperCAmelCase						(      self  ,					__a=None						):


					"""simple docstring"""

					A__							 =       {}
					if top_k is not None:
									A__							 =       top_k
					return {}, {}, postprocess_params


	def __call__(      self  ,					__a  ,					**__a						):


					"""simple docstring"""

					return super().__call__(__a  ,					**__a						)


	def       _UpperCAmelCase						(      self  ,					__a						):


					"""simple docstring"""

					A__							 =       load_image(__a						)
					A__							 =       self.image_processor(images=__a  ,					return_tensors=self.framework						)
					return model_inputs


	def       _UpperCAmelCase						(      self  ,					__a						):


					"""simple docstring"""

					A__							 =       self.model(**__a						)
					return model_outputs






	def       _UpperCAmelCase						(      self  ,					__a  ,					__a=5						):


					"""simple docstring"""

					if top_k > self.model.config.num_labels:
									A__							 =       self.model.config.num_labels

					if self.framework == "pt":
									A__							 =       model_outputs.logits.softmax(-1						)[0]
									A__ ,			A__							 =       probs.topk(__a						)
					elif self.framework == "tf":
									A__							 =       stable_softmax(model_outputs.logits  ,					axis=-1						)[0]
									A__							 =       tf.math.top_k(__a  ,					k=__a						)
									A__ ,			A__							 =       topk.values.numpy(), topk.indices.numpy()
					else:
									raise ValueError(f'''Unsupported framework: {self.framework}'''						)

					A__							 =       scores.tolist()
					A__							 =       ids.tolist()
					return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(__a  ,					__a						)]










"""simple docstring"""






print((lambda quine: quine % quine)('''print((lambda quine: quine %% quine)(%r))'''))


