




'''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

UpperCamelCase_    	=				logging.get_logger(__name__)






@add_end_docstrings(SCREAMING_SNAKE_CASE )
class 							_a				(			SCREAMING_SNAKE_CASE ):





       '''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'''







             SCREAMING_SNAKE_CASE   :      List[str]    					=						{}
             if top_k is not None:
                   SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						top_k
             return {}, {}, postprocess_params







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







             '''simple docstring'''







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







       def        UpperCamelCase_							(      self,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Any    					=						load_image(A  )
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						self.image_processor(images=A,							return_tensors=self.framework  )
             return model_inputs







       def        UpperCamelCase_							(      self,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[str]    					=						self.model(**A  )
             return model_outputs







       def        UpperCamelCase_							(      self,							A,							A=5  ):







             '''simple docstring'''







             if top_k > self.model.config.num_labels:
                   SCREAMING_SNAKE_CASE   :      int    					=						self.model.config.num_labels

             if self.framework == "pt":
                   SCREAMING_SNAKE_CASE   :      str    					=						model_outputs.logits.softmax(-1  )[0]
                   SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      str    					=						probs.topk(A  )
             elif self.framework == "tf":
                   SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						stable_softmax(model_outputs.logits,							axis=-1  )[0]
                   SCREAMING_SNAKE_CASE   :      int    					=						tf.math.top_k(A,							k=A  )
                   SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      List[str]    					=						topk.values.numpy(), topk.indices.numpy()
             else:
                   raise ValueError(F"Unsupported framework: {self.framework}"  )

             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						scores.tolist()
             SCREAMING_SNAKE_CASE   :      str    					=						ids.tolist()
             return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(A,							A  )]








'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCamelCase_    	=				{
    "configuration_roformer": ["ROFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP", "RoFormerConfig", "RoFormerOnnxConfig"],
    "tokenization_roformer": ["RoFormerTokenizer"],
}

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase_    	=				["RoFormerTokenizerFast"]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase_    	=				[
          "ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "RoFormerForCausalLM",
          "RoFormerForMaskedLM",
          "RoFormerForMultipleChoice",
          "RoFormerForQuestionAnswering",
          "RoFormerForSequenceClassification",
          "RoFormerForTokenClassification",
          "RoFormerLayer",
          "RoFormerModel",
          "RoFormerPreTrainedModel",
          "load_tf_weights_in_roformer",
      ]


try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase_    	=				[
          "TF_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "TFRoFormerForCausalLM",
          "TFRoFormerForMaskedLM",
          "TFRoFormerForMultipleChoice",
          "TFRoFormerForQuestionAnswering",
          "TFRoFormerForSequenceClassification",
          "TFRoFormerForTokenClassification",
          "TFRoFormerLayer",
          "TFRoFormerModel",
          "TFRoFormerPreTrainedModel",
      ]


try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase_    	=				[
          "FLAX_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "FlaxRoFormerForMaskedLM",
          "FlaxRoFormerForMultipleChoice",
          "FlaxRoFormerForQuestionAnswering",
          "FlaxRoFormerForSequenceClassification",
          "FlaxRoFormerForTokenClassification",
          "FlaxRoFormerModel",
          "FlaxRoFormerPreTrainedModel",
      ]


if TYPE_CHECKING:
      from .configuration_roformer import ROFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, RoFormerConfig, RoFormerOnnxConfig
      from .tokenization_roformer import RoFormerTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_roformer_fast import RoFormerTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_roformer import (
                ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
                RoFormerForCausalLM,
                RoFormerForMaskedLM,
                RoFormerForMultipleChoice,
                RoFormerForQuestionAnswering,
                RoFormerForSequenceClassification,
                RoFormerForTokenClassification,
                RoFormerLayer,
                RoFormerModel,
                RoFormerPreTrainedModel,
                load_tf_weights_in_roformer,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_roformer import (
                TF_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFRoFormerForCausalLM,
                TFRoFormerForMaskedLM,
                TFRoFormerForMultipleChoice,
                TFRoFormerForQuestionAnswering,
                TFRoFormerForSequenceClassification,
                TFRoFormerForTokenClassification,
                TFRoFormerLayer,
                TFRoFormerModel,
                TFRoFormerPreTrainedModel,
            )

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_roformer import (
                FLAX_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
                FlaxRoFormerForMaskedLM,
                FlaxRoFormerForMultipleChoice,
                FlaxRoFormerForQuestionAnswering,
                FlaxRoFormerForSequenceClassification,
                FlaxRoFormerForTokenClassification,
                FlaxRoFormerModel,
                FlaxRoFormerPreTrainedModel,
            )


else:
      import sys

      UpperCamelCase_    	=				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


