




'''simple docstring'''



# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


UpperCamelCase_    	=				{
    "configuration_efficientnet": [
        "EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "EfficientNetConfig",
        "EfficientNetOnnxConfig",
    ]
}

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

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase_    	=				[
          "EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST",
          "EfficientNetForImageClassification",
          "EfficientNetModel",
          "EfficientNetPreTrainedModel",
      ]

if TYPE_CHECKING:
      from .configuration_efficientnet import (
          EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP,
          EfficientNetConfig,
          EfficientNetOnnxConfig,
      )

      try:
            if not is_vision_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .image_processing_efficientnet import EfficientNetImageProcessor

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_efficientnet import (
                EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST,
                EfficientNetForImageClassification,
                EfficientNetModel,
                EfficientNetPreTrainedModel,
            )

else:
      import sys

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








'''simple docstring'''



import warnings

from transformers import AutoTokenizer
from transformers.utils import is_torch_available
from transformers.utils.generic import ExplicitEnum

from ...processing_utils import ProcessorMixin


if is_torch_available():
      import torch






class 							_a				(			SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				Dict        =						'''char'''
       A						:				Any        =						'''bpe'''
       A						:				Dict        =						'''wp'''

UpperCamelCase_    	=				(DecodeType.CHARACTER, DecodeType.BPE, DecodeType.WORDPIECE)






class 							_a				(			SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				List[Any]        =						['''image_processor''', '''char_tokenizer''']
       A						:				int        =						'''ViTImageProcessor'''
       A						:				List[str]        =						'''MgpstrTokenizer'''







       def __init__(      self,							A=None,							A=None,							**A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						None
             if "feature_extractor" in kwargs:
                   warnings.warn(
                       'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
                       ' instead.',							A,							)
                   SCREAMING_SNAKE_CASE   :      str    					=						kwargs.pop('feature_extractor'  )

             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						image_processor if image_processor is not None else feature_extractor
             if image_processor is None:
                   raise ValueError('You need to specify an `image_processor`.'  )
             if tokenizer is None:
                   raise ValueError('You need to specify a `tokenizer`.'  )

             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						tokenizer
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						AutoTokenizer.from_pretrained('gpt2'  )
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						AutoTokenizer.from_pretrained('bert-base-uncased'  )

             super().__init__(A,							A  )







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







             '''simple docstring'''







             if images is None and text is None:
                   raise ValueError('You need to specify either an `images` or `text` input to process.'  )

             if images is not None:
                   SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						self.image_processor(A,							return_tensors=A,							**A  )
             if text is not None:
                   SCREAMING_SNAKE_CASE   :      int    					=						self.char_tokenizer(A,							return_tensors=A,							**A  )

             if text is None:
                   return inputs
             elif images is None:
                   return encodings
             else:
                   SCREAMING_SNAKE_CASE   :      Any    					=						encodings['input_ids']
                   return inputs







       def        UpperCamelCase_							(      self,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      int    					=						sequences
             SCREAMING_SNAKE_CASE   :      List[str]    					=						char_preds.size(0  )

             SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      Dict    					=						self._decode_helper(A,							'char'  )
             SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      int    					=						self._decode_helper(A,							'bpe'  )
             SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						self._decode_helper(A,							'wp'  )

             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						[]
             SCREAMING_SNAKE_CASE   :      Tuple    					=						[]
             for i in range(A  ):
                   SCREAMING_SNAKE_CASE   :      str    					=						[char_scores[i], bpe_scores[i], wp_scores[i]]
                   SCREAMING_SNAKE_CASE   :      Dict    					=						[char_strs[i], bpe_strs[i], wp_strs[i]]
                   SCREAMING_SNAKE_CASE   :      List[str]    					=						scores.index(max(A  )  )
                   final_strs.append(strs[max_score_index]  )
                   final_scores.append(scores[max_score_index]  )

             SCREAMING_SNAKE_CASE   :      List[Any]    					=						{}
             SCREAMING_SNAKE_CASE   :      int    					=						final_strs
             SCREAMING_SNAKE_CASE   :      Any    					=						final_scores
             SCREAMING_SNAKE_CASE   :      Dict    					=						char_strs
             SCREAMING_SNAKE_CASE   :      Any    					=						bpe_strs
             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						wp_strs
             return out







       def        UpperCamelCase_							(      self,							A,							A  ):







             '''simple docstring'''







             if format == DecodeType.CHARACTER:
                   SCREAMING_SNAKE_CASE   :      List[Any]    					=						self.char_decode
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						1
                   SCREAMING_SNAKE_CASE   :      str    					=						'[s]'
             elif format == DecodeType.BPE:
                   SCREAMING_SNAKE_CASE   :      str    					=						self.bpe_decode
                   SCREAMING_SNAKE_CASE   :      str    					=						2
                   SCREAMING_SNAKE_CASE   :      List[str]    					=						'#'
             elif format == DecodeType.WORDPIECE:
                   SCREAMING_SNAKE_CASE   :      Any    					=						self.wp_decode
                   SCREAMING_SNAKE_CASE   :      Tuple    					=						102
                   SCREAMING_SNAKE_CASE   :      List[Any]    					=						'[SEP]'
             else:
                   raise ValueError(F"Format {format} is not supported."  )

             SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						[], []
             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						pred_logits.size(0  )
             SCREAMING_SNAKE_CASE   :      Any    					=						pred_logits.size(1  )
             SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      List[Any]    					=						pred_logits.topk(1,							dim=-1,							largest=A,							sorted=A  )
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						preds_index.view(-1,							A  )[:, 1:]
             SCREAMING_SNAKE_CASE   :      List[Any]    					=						decoder(A  )
             SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      Optional[int]    					=						torch.nn.functional.softmax(A,							dim=2  ).max(dim=2  )
             SCREAMING_SNAKE_CASE   :      Dict    					=						preds_max_prob[:, 1:]

             for index in range(A  ):
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						preds_str[index].find(A  )
                   SCREAMING_SNAKE_CASE   :      List[Any]    					=						preds_str[index][:pred_eos]
                   SCREAMING_SNAKE_CASE   :      Dict    					=						preds_index[index].cpu().tolist()
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						pred_index.index(A  ) if eos_token in pred_index else -1
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						preds_max_prob[index][: pred_eos_index + 1]
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						pred_max_prob.cumprod(dim=0  )[-1] if pred_max_prob.nelement() != 0 else 0.0
                   dec_strs.append(A  )
                   conf_scores.append(A  )

             return dec_strs, conf_scores







       def        UpperCamelCase_							(      self,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						[seq.replace(' ',							''  ) for seq in self.char_tokenizer.batch_decode(A  )]
             return decode_strs







       def        UpperCamelCase_							(      self,							A  ):







             '''simple docstring'''







             return self.bpe_tokenizer.batch_decode(A  )







       def        UpperCamelCase_							(      self,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[str]    					=						[seq.replace(' ',							''  ) for seq in self.wp_tokenizer.batch_decode(A  )]
             return decode_strs


