


from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase							=logging.get_logger(__name__)

lowercase							={
    'weiweishi/roc-bert-base-zh': 'https://huggingface.co/weiweishi/roc-bert-base-zh/resolve/main/config.json',
}






class  __magic_name__							(		lowerCAmelCase    ):
       UpperCAmelCase										="roc_bert"






       def __init__(      self  ,							snake_case=3_0_5_2_2  ,							snake_case=7_6_8  ,							snake_case=1_2  ,							snake_case=1_2  ,							snake_case=3_0_7_2  ,							snake_case="gelu"  ,							snake_case=0.1  ,							snake_case=0.1  ,							snake_case=5_1_2  ,							snake_case=2  ,							snake_case=0.02  ,							snake_case=1E-1_2  ,							snake_case=True  ,							snake_case=0  ,							snake_case="absolute"  ,							snake_case=None  ,							snake_case=True  ,							snake_case=True  ,							snake_case=7_6_8  ,							snake_case=9_1_0  ,							snake_case=5_1_2  ,							snake_case=2_4_8_5_8  ,							snake_case=True  ,							**snake_case  ,							)						->  int:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[int]							   =vocab_size
          _UpperCAmelCase       :       List[Any]							   =max_position_embeddings
          _UpperCAmelCase       :       List[str]							   =hidden_size
          _UpperCAmelCase       :       int							   =num_hidden_layers
          _UpperCAmelCase       :       Tuple							   =num_attention_heads
          _UpperCAmelCase       :       List[Any]							   =intermediate_size
          _UpperCAmelCase       :       Union[str, Any]							   =hidden_act
          _UpperCAmelCase       :       str							   =hidden_dropout_prob
          _UpperCAmelCase       :       int							   =attention_probs_dropout_prob
          _UpperCAmelCase       :       Optional[int]							   =initializer_range
          _UpperCAmelCase       :       Any							   =type_vocab_size
          _UpperCAmelCase       :       Tuple							   =layer_norm_eps
          _UpperCAmelCase       :       Optional[int]							   =use_cache
          _UpperCAmelCase       :       Union[str, Any]							   =enable_pronunciation
          _UpperCAmelCase       :       Optional[Any]							   =enable_shape
          _UpperCAmelCase       :       Optional[int]							   =pronunciation_embed_dim
          _UpperCAmelCase       :       Optional[Any]							   =pronunciation_vocab_size
          _UpperCAmelCase       :       Any							   =shape_embed_dim
          _UpperCAmelCase       :       str							   =shape_vocab_size
          _UpperCAmelCase       :       Optional[Any]							   =concat_input
          _UpperCAmelCase       :       List[str]							   =position_embedding_type
          _UpperCAmelCase       :       str							   =classifier_dropout
          super().__init__(pad_token_id=snake_case  ,							**snake_case)





'''simple docstring'''






from collections import UserDict
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_torch_available():
 from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING

if is_tf_available():
 from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
 from ..tf_utils import stable_softmax

lowercase							=logging.get_logger(__name__)






@add_end_docstrings(lowerCAmelCase    )
class  __magic_name__							(		lowerCAmelCase    ):






       def __init__(      self  ,							**snake_case)						->  Optional[int]:




          '''simple docstring'''
          super().__init__(**snake_case)

          requires_backends(self  ,							'vision')
          self.check_model_type(
              TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
              if self.framework == 'tf'
              else MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING)






       def __call__(      self  ,							snake_case  ,							**snake_case)						->  str:




          '''simple docstring'''
          return super().__call__(snake_case  ,							**snake_case)






       def       lowerCAmelCase		(      self  ,							**snake_case)						->  int:




          '''simple docstring'''
          _UpperCAmelCase       :       str							   ={}
          if "candidate_labels" in kwargs:
             _UpperCAmelCase       :       Union[str, Any]							   =kwargs['candidate_labels']
          if "hypothesis_template" in kwargs:
             _UpperCAmelCase       :       List[Any]							   =kwargs['hypothesis_template']

          return preprocess_params, {}, {}






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case=None  ,							snake_case="This is a photo of {}.")						->  Any:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[Any]							   =load_image(snake_case)
          _UpperCAmelCase       :       Union[str, Any]							   =self.image_processor(images=[image]  ,							return_tensors=self.framework)
          _UpperCAmelCase       :       Union[str, Any]							   =candidate_labels
          _UpperCAmelCase       :       List[Any]							   =[hypothesis_template.format(snake_case) for x in candidate_labels]
          _UpperCAmelCase       :       str							   =self.tokenizer(snake_case  ,							return_tensors=self.framework  ,							padding=snake_case)
          _UpperCAmelCase       :       Any							   =[text_inputs]
          return inputs






       def       lowerCAmelCase		(      self  ,							snake_case)						->  str:




          '''simple docstring'''
          _UpperCAmelCase       :       List[str]							   =model_inputs.pop('candidate_labels')
          _UpperCAmelCase       :       Tuple							   =model_inputs.pop('text_inputs')
          if isinstance(text_inputs[0]  ,							snake_case):
             _UpperCAmelCase       :       Any							   =text_inputs[0]
          else:
             # Batching case.
             _UpperCAmelCase       :       str							   =text_inputs[0][0]

          _UpperCAmelCase       :       Any							   =self.model(**snake_case  ,							**snake_case)

          _UpperCAmelCase       :       List[str]							   ={
              'candidate_labels': candidate_labels,
              'logits': outputs.logits_per_image,
          }
          return model_outputs






       def       lowerCAmelCase		(      self  ,							snake_case)						->  Optional[int]:




          '''simple docstring'''
          _UpperCAmelCase       :       str							   =model_outputs.pop('candidate_labels')
          _UpperCAmelCase       :       Union[str, Any]							   =model_outputs['logits'][0]
          if self.framework == "pt":
             _UpperCAmelCase       :       Dict							   =logits.softmax(dim=-1).squeeze(-1)
             _UpperCAmelCase       :       Union[str, Any]							   =probs.tolist()
             if not isinstance(snake_case  ,							snake_case):
                _UpperCAmelCase       :       Union[str, Any]							   =[scores]
          elif self.framework == "tf":
             _UpperCAmelCase       :       Dict							   =stable_softmax(snake_case  ,							axis=-1)
             _UpperCAmelCase       :       str							   =probs.numpy().tolist()
          else:
             raise ValueError(f"Unsupported framework: {self.framework}")

          _UpperCAmelCase       :       List[str]							   =[
              {'score': score, 'label': candidate_label}
              for score, candidate_label in sorted(zip(snake_case  ,							snake_case)  ,							key=lambda snake_case: -x[0])
          ]
          return result

