
'''simple docstring'''



import os
from pickle import UnpicklingError
from typing import Dict, Tuple

import jax
import jax.numpy as jnp
import numpy as np
from flax.serialization import from_bytes
from flax.traverse_util import flatten_dict, unflatten_dict

import transformers

from .utils import logging


_lowercase          =						logging.get_logger(__name__)


def A (__lowerCamelCase :str					,      __lowerCamelCase :List[str]					,      __lowerCamelCase :str					,      __lowerCamelCase :Optional[Any]=False						):
						try:
												import torch  # noqa: F401
						except ImportError:
												logger.error(
												    """Loading a PyTorch model in Flax, requires both PyTorch and Flax to be installed. Please see"""
												    """ https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation"""
												    """ instructions."""						)
												raise

						if not is_sharded:
												_lowerCAmelCase    		=					os.path.abspath(__lowerCamelCase						)
												logger.info(f'Loading PyTorch weights from {pt_path}'						)

												_lowerCAmelCase    		=					torch.load(__lowerCamelCase					,      map_location="""cpu"""						)
												logger.info(f'PyTorch checkpoint contains {sum(t.numel() for t in pt_state_dict.values()						):,} parameters.'						)

												_lowerCAmelCase    		=					convert_pytorch_state_dict_to_flax(__lowerCamelCase					,      __lowerCamelCase						)
						else:
												# model is sharded and pytorch_checkpoint_path already contains the list of .pt shard files
												_lowerCAmelCase    		=					convert_pytorch_sharded_state_dict_to_flax(__lowerCamelCase					,      __lowerCamelCase						)
						return flax_state_dict


def A (__lowerCamelCase :Tuple[str]					,      __lowerCamelCase :np.ndarray					,      __lowerCamelCase :Dict[str, jnp.ndarray]					,      __lowerCamelCase :str					,      ):

						def is_key_or_prefix_key_in_dict(__lowerCamelCase :Tuple[str]						) -> bool:
												return len(set(__lowerCamelCase						) & {key, (model_prefix,) + key}						) > 0

						# layer norm
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""scale""",)
						if pt_tuple_key[-1] in ["weight", "gamma"] and is_key_or_prefix_key_in_dict(__lowerCamelCase						):
												return renamed_pt_tuple_key, pt_tensor

						# batch norm layer mean
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""mean""",)
						if pt_tuple_key[-1] == "running_mean" and not is_key_or_prefix_key_in_dict(__lowerCamelCase						):
												return renamed_pt_tuple_key, pt_tensor

						# batch norm layer var
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""var""",)
						if pt_tuple_key[-1] == "running_var" and not is_key_or_prefix_key_in_dict(__lowerCamelCase						):
												return renamed_pt_tuple_key, pt_tensor

						# embedding
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""embedding""",)
						if pt_tuple_key[-1] == "weight" and is_key_or_prefix_key_in_dict(__lowerCamelCase						):
												return renamed_pt_tuple_key, pt_tensor

						# conv layer
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""kernel""",)
						if pt_tuple_key[-1] == "weight" and pt_tensor.ndim == 4 and not is_key_or_prefix_key_in_dict(__lowerCamelCase						):
												_lowerCAmelCase    		=					pt_tensor.transpose(2					,      3					,      1					,      0						)
												return renamed_pt_tuple_key, pt_tensor

						# linear layer
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""kernel""",)
						if pt_tuple_key[-1] == "weight" and not is_key_or_prefix_key_in_dict(__lowerCamelCase						):
												_lowerCAmelCase    		=					pt_tensor.T
												return renamed_pt_tuple_key, pt_tensor

						# old PyTorch layer norm weight
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""weight""",)
						if pt_tuple_key[-1] == "gamma":
												return renamed_pt_tuple_key, pt_tensor

						# old PyTorch layer norm bias
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""bias""",)
						if pt_tuple_key[-1] == "beta":
												return renamed_pt_tuple_key, pt_tensor

						# New `weight_norm` from https://github.com/huggingface/transformers/pull/24030
						_lowerCAmelCase    		=					None
						if pt_tuple_key[-3::2] == ("parametrizations", "original0"):
												_lowerCAmelCase    		=					pt_tuple_key[-2] + """_g"""
						elif pt_tuple_key[-3::2] == ("parametrizations", "original1"):
												_lowerCAmelCase    		=					pt_tuple_key[-2] + """_v"""
						if name is not None:
												_lowerCAmelCase    		=					pt_tuple_key[:-3] + (name,)
												return renamed_pt_tuple_key, pt_tensor

						return pt_tuple_key, pt_tensor


def A (__lowerCamelCase :Union[str, Any]					,      __lowerCamelCase :Dict						):
						# convert pytorch tensor to numpy
						_lowerCAmelCase    		=					{k: v.numpy() for k, v in pt_state_dict.items()}

						_lowerCAmelCase    		=					flax_model.base_model_prefix

						# use params dict if the model contains batch norm layers
						if "params" in flax_model.params:
												_lowerCAmelCase    		=					flax_model.params["""params"""]
						else:
												_lowerCAmelCase    		=					flax_model.params
						_lowerCAmelCase    		=					flatten_dict(__lowerCamelCase						)

						# add batch_stats keys,values to dict
						if "batch_stats" in flax_model.params:
												_lowerCAmelCase    		=					flatten_dict(flax_model.params["""batch_stats"""]						)
												random_flax_state_dict.update(__lowerCamelCase						)

						_lowerCAmelCase    		=					{}

						_lowerCAmelCase    		=					(model_prefix not in flax_model_params) and (
						    model_prefix in {k.split("""."""						)[0] for k in pt_state_dict.keys()}
						)
						_lowerCAmelCase    		=					(model_prefix in flax_model_params) and (
						    model_prefix not in {k.split("""."""						)[0] for k in pt_state_dict.keys()}
						)

						# Need to change some parameters name to match Flax names
						for pt_key, pt_tensor in pt_state_dict.items():
												_lowerCAmelCase    		=					tuple(pt_key.split("""."""						)						)

												# remove base model prefix if necessary
												_lowerCAmelCase    		=					pt_tuple_key[0] == model_prefix
												if load_model_with_head_into_base_model and has_base_model_prefix:
																		_lowerCAmelCase    		=					pt_tuple_key[1:]

												# Correctly rename weight parameters
												_lowerCAmelCase		,       _lowerCAmelCase    		=					rename_key_and_reshape_tensor(
												    __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase						)

												# add model prefix if necessary
												_lowerCAmelCase    		=					(model_prefix,) + flax_key in random_flax_state_dict
												if load_base_model_into_model_with_head and require_base_model_prefix:
																		_lowerCAmelCase    		=					(model_prefix,) + flax_key

												if flax_key in random_flax_state_dict:
																		if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
																								raise ValueError(
																								    f'PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape '
																								    f'{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.'						)

        # add batch stats if the model contains batchnorm layers
												if "batch_stats" in flax_model.params:
																		if "mean" in flax_key[-1] or "var" in flax_key[-1]:
																								_lowerCAmelCase    		=					jnp.asarray(__lowerCamelCase						)
																								continue
																		# remove num_batches_tracked key
																		if "num_batches_tracked" in flax_key[-1]:
																								flax_state_dict.pop(__lowerCamelCase					,      __lowerCamelCase						)
																								continue

																		# also add unexpected weight so that warning is thrown
																		_lowerCAmelCase    		=					jnp.asarray(__lowerCamelCase						)

												else:
																		# also add unexpected weight so that warning is thrown
																		_lowerCAmelCase    		=					jnp.asarray(__lowerCamelCase						)

						return unflatten_dict(__lowerCamelCase						)


def A (__lowerCamelCase :List[str]					,      __lowerCamelCase :List[str]						):
						import torch

						# Load the index
						_lowerCAmelCase    		=					{}
						for shard_file in shard_filenames:
												# load using msgpack utils
												_lowerCAmelCase    		=					torch.load(__lowerCamelCase						)
												_lowerCAmelCase    		=					{k: v.numpy() for k, v in pt_state_dict.items()}

												_lowerCAmelCase    		=					flax_model.base_model_prefix

												# use params dict if the model contains batch norm layers and then add batch_stats keys,values to dict
												if "batch_stats" in flax_model.params:
																		_lowerCAmelCase    		=					flax_model.params["""params"""]

																		_lowerCAmelCase    		=					flatten_dict(__lowerCamelCase						)
																		random_flax_state_dict.update(flatten_dict(flax_model.params["""batch_stats"""]						)						)
												else:
																		_lowerCAmelCase    		=					flax_model.params
																		_lowerCAmelCase    		=					flatten_dict(__lowerCamelCase						)

												_lowerCAmelCase    		=					(model_prefix not in flax_model_params) and (
												    model_prefix in {k.split("""."""						)[0] for k in pt_state_dict.keys()}
												)
												_lowerCAmelCase    		=					(model_prefix in flax_model_params) and (
												    model_prefix not in {k.split("""."""						)[0] for k in pt_state_dict.keys()}
												)
												# Need to change some parameters name to match Flax names
												for pt_key, pt_tensor in pt_state_dict.items():
																		_lowerCAmelCase    		=					tuple(pt_key.split("""."""						)						)

																		# remove base model prefix if necessary
																		_lowerCAmelCase    		=					pt_tuple_key[0] == model_prefix
																		if load_model_with_head_into_base_model and has_base_model_prefix:
																								_lowerCAmelCase    		=					pt_tuple_key[1:]

																		# Correctly rename weight parameters
																		_lowerCAmelCase		,       _lowerCAmelCase    		=					rename_key_and_reshape_tensor(
																		    __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase						)
																		# add model prefix if necessary
																		_lowerCAmelCase    		=					(model_prefix,) + flax_key in random_flax_state_dict
																		if load_base_model_into_model_with_head and require_base_model_prefix:
																								_lowerCAmelCase    		=					(model_prefix,) + flax_key

																		if flax_key in random_flax_state_dict:
																								if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
																														raise ValueError(
																														    f'PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape '
																														    f'{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.'						)

            # add batch stats if the model contains batchnorm layers
																		if "batch_stats" in flax_model.params:
																								if "mean" in flax_key[-1]:
																														_lowerCAmelCase    		=					jnp.asarray(__lowerCamelCase						)
																														continue
																								if "var" in flax_key[-1]:
																														_lowerCAmelCase    		=					jnp.asarray(__lowerCamelCase						)
																														continue
																								# remove num_batches_tracked key
																								if "num_batches_tracked" in flax_key[-1]:
																														flax_state_dict.pop(__lowerCamelCase					,      __lowerCamelCase						)
																														continue

																								# also add unexpected weight so that warning is thrown
																								_lowerCAmelCase    		=					jnp.asarray(__lowerCamelCase						)

																		else:
																								# also add unexpected weight so that warning is thrown
																								_lowerCAmelCase    		=					jnp.asarray(__lowerCamelCase						)
						return unflatten_dict(__lowerCamelCase						)


def A (__lowerCamelCase :Tuple					,      __lowerCamelCase :List[str]						):
						_lowerCAmelCase    		=					os.path.abspath(__lowerCamelCase						)
						logger.info(f'Loading Flax weights from {flax_checkpoint_path}'						)

						# import correct flax class
						_lowerCAmelCase    		=					getattr(__lowerCamelCase					,      """Flax""" + model.__class__.__name__						)

						# load flax weight dict
						with open(__lowerCamelCase					,      """rb"""						) as state_f:
												try:
																		_lowerCAmelCase    		=					from_bytes(__lowerCamelCase					,      state_f.read()						)
												except UnpicklingError:
																		raise EnvironmentError(f'Unable to convert {flax_checkpoint_path} to Flax deserializable object. '						)

						return load_flax_weights_in_pytorch_model(__lowerCamelCase					,      __lowerCamelCase						)





def A (__lowerCamelCase :Optional[int]					,      __lowerCamelCase :Optional[int]						):

						try:
												import torch  # noqa: F401
						except ImportError:
												logger.error(
												    """Loading a Flax weights in PyTorch, requires both PyTorch and Flax to be installed. Please see"""
												    """ https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation"""
												    """ instructions."""						)
												raise

						# check if we have bf16 weights
						_lowerCAmelCase    		=					flatten_dict(jax.tree_util.tree_map(lambda __lowerCamelCase						: x.dtype == jnp.bfloataa					,      __lowerCamelCase						)						).values()
						if any(__lowerCamelCase						):
												# convert all weights to fp32 if the are bf16 since torch.from_numpy can-not handle bf16
												# and bf16 is not fully supported in PT yet.
												logger.warning(
												    """Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` """
												    """before loading those in PyTorch model."""						)
												_lowerCAmelCase    		=					jax.tree_util.tree_map(
												    lambda __lowerCamelCase						: params.astype(np.floataa						) if params.dtype == jnp.bfloataa else params					,      __lowerCamelCase						)

						_lowerCAmelCase    		=					flatten_dict(__lowerCamelCase						)
						_lowerCAmelCase    		=					pt_model.state_dict()

						_lowerCAmelCase    		=					(pt_model.base_model_prefix in flax_state) and (
						    pt_model.base_model_prefix not in {k.split("""."""						)[0] for k in pt_model_dict.keys()}
						)
						_lowerCAmelCase    		=					(pt_model.base_model_prefix not in flax_state) and (
						    pt_model.base_model_prefix in {k.split("""."""						)[0] for k in pt_model_dict.keys()}
						)

						# keep track of unexpected & missing keys
						_lowerCAmelCase    		=					[]
						_lowerCAmelCase    		=					set(pt_model_dict.keys()						)

						for flax_key_tuple, flax_tensor in flax_state_dict.items():
												_lowerCAmelCase    		=					flax_key_tuple[0] == pt_model.base_model_prefix
												_lowerCAmelCase    		=					""".""".join((pt_model.base_model_prefix,) + flax_key_tuple						) in pt_model_dict

												# adapt flax_key to prepare for loading from/to base model only
												if load_model_with_head_into_base_model and has_base_model_prefix:
																		_lowerCAmelCase    		=					flax_key_tuple[1:]
												elif load_base_model_into_model_with_head and require_base_model_prefix:
																		_lowerCAmelCase    		=					(pt_model.base_model_prefix,) + flax_key_tuple

												# rename flax weights to PyTorch format
												if flax_key_tuple[-1] == "kernel" and flax_tensor.ndim == 4 and ".".join(__lowerCamelCase						) not in pt_model_dict:
																		# conv layer
																		_lowerCAmelCase    		=					flax_key_tuple[:-1] + ("""weight""",)
																		_lowerCAmelCase    		=					jnp.transpose(__lowerCamelCase					,      (3, 2, 0, 1)						)
												elif flax_key_tuple[-1] == "kernel" and ".".join(__lowerCamelCase						) not in pt_model_dict:
																		# linear layer
																		_lowerCAmelCase    		=					flax_key_tuple[:-1] + ("""weight""",)
																		_lowerCAmelCase    		=					flax_tensor.T
												elif flax_key_tuple[-1] in ["scale", "embedding"]:
																		_lowerCAmelCase    		=					flax_key_tuple[:-1] + ("""weight""",)

												# adding batch stats from flax batch norm to pt
												elif "mean" in flax_key_tuple[-1]:
																		_lowerCAmelCase    		=					flax_key_tuple[:-1] + ("""running_mean""",)
												elif "var" in flax_key_tuple[-1]:
																		_lowerCAmelCase    		=					flax_key_tuple[:-1] + ("""running_var""",)

												if "batch_stats" in flax_state:
																		_lowerCAmelCase    		=					""".""".join(flax_key_tuple[1:]						)  # Remove the params/batch_stats header
												else:
																		_lowerCAmelCase    		=					""".""".join(__lowerCamelCase						)

												# We also need to look at `pt_model_dict` and see if there are keys requiring further transformation.
												_lowerCAmelCase    		=					{}
												# New `weight_norm` from https://github.com/huggingface/transformers/pull/24030
												for key in pt_model_dict:
																		_lowerCAmelCase    		=					key.split("""."""						)
																		_lowerCAmelCase    		=					None
																		if key_components[-3::2] == ["parametrizations", "original0"]:
																								_lowerCAmelCase    		=					key_components[-2] + """_g"""
																		elif key_components[-3::2] == ["parametrizations", "original1"]:
																								_lowerCAmelCase    		=					key_components[-2] + """_v"""
																		if name is not None:
																								_lowerCAmelCase    		=					key_components[:-3] + [name]
																								_lowerCAmelCase    		=					""".""".join(__lowerCamelCase						)
																								_lowerCAmelCase    		=					key

												if flax_key in special_pt_names:
																		_lowerCAmelCase    		=					special_pt_names[flax_key]

												if flax_key in pt_model_dict:
																		if flax_tensor.shape != pt_model_dict[flax_key].shape:
																								raise ValueError(
																								    f'Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected '
																								    f'to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}.'						)
																		else:
																								# add weight to pytorch dict
																								_lowerCAmelCase    		=					np.asarray(__lowerCamelCase						) if not isinstance(__lowerCamelCase					,      np.ndarray						) else flax_tensor
																								_lowerCAmelCase    		=					torch.from_numpy(__lowerCamelCase						)
																								# remove from missing keys
																								missing_keys.remove(__lowerCamelCase						)
												else:
																		# weight is not expected by PyTorch model
																		unexpected_keys.append(__lowerCamelCase						)

						pt_model.load_state_dict(__lowerCamelCase						)

						# re-transform missing_keys to list
						_lowerCAmelCase    		=					list(__lowerCamelCase						)

						if len(__lowerCamelCase						) > 0:
												logger.warning(
												    """Some weights of the Flax model were not used when initializing the PyTorch model"""
												    f' {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing'
												    f' {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture'
												    """ (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This"""
												    f' IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect'
												    """ to be exactly identical (e.g. initializing a BertForSequenceClassification model from a"""
												    """ FlaxBertForSequenceClassification model)."""						)
						else:
												logger.warning(f'All Flax model weights were used when initializing {pt_model.__class__.__name__}.\n'						)
						if len(__lowerCamelCase						) > 0:
												logger.warning(
												    f'Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly'
												    f' initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to'
												    """ use it for predictions and inference."""						)
						else:
												logger.warning(
												    f'All the weights of {pt_model.__class__.__name__} were initialized from the Flax model.\n'
												    """If your task is similar to the task the model of the checkpoint was trained on, """
												    f'you can already use {pt_model.__class__.__name__} for predictions without further training.'						)

						return pt_model






import warnings
from typing import Dict

import numpy as np

from ..utils import ExplicitEnum, add_end_docstrings, is_tf_available, is_torch_available
from .base import PIPELINE_INIT_ARGS, GenericTensor, Pipeline


if is_tf_available():
  from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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







def SCREAMING_SNAKE_CASE							(			lowercase_		)  ->			int:



       """simple docstring"""

       return 1.0 / (1.0 + np.exp(-_outputs		))







def SCREAMING_SNAKE_CASE							(			lowercase_		)  ->			Union[str, Any]:



       """simple docstring"""

       A__ 					=       np.max(_outputs					,							axis=-1					,							keepdims=lowercase_		)
       A__ 					=       np.exp(_outputs - maxes		)
       return shifted_exp / shifted_exp.sum(axis=-1					,							keepdims=lowercase_		)


class 							UpperCamelCase_       (					UpperCAmelCase__	):

    '''simple docstring'''






    UpperCAmelCase__				    = '''sigmoid'''
    UpperCAmelCase__				    = '''softmax'''
    UpperCAmelCase__				    = '''none'''


@add_end_docstrings(
    UpperCAmelCase__						,   R'''
        return_all_scores (`bool`, *optional*, defaults to `False`):
            Whether to return all prediction scores or just the one of the predicted class.
        function_to_apply (`str`, *optional*, defaults to `"default"`):
            The function to apply to the model outputs in order to retrieve the scores. Accepts four different values:

            - `"default"`: if the model has a single label, will apply the sigmoid function on the output. If the model
              has several labels, will apply the softmax function on the output.
            - `"sigmoid"`: Applies the sigmoid function on the output.
            - `"softmax"`: Applies the softmax function on the output.
            - `"none"`: Does not apply any function on the output.
    '''						,   )
class 							UpperCamelCase_       (					UpperCAmelCase__	):

    '''simple docstring'''






    UpperCAmelCase__				    = False
    UpperCAmelCase__				    = ClassificationFunction.NONE


    def __init__(     self :      Any   ,					**UpperCAmelCase__ :      Optional[Any])		->str:





           '''simple docstring'''

           super().__init__(**UpperCAmelCase__)

           self.check_model_type(
               TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
               if self.framework == '''tf'''
               else MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING)


    def 			SCREAMING_SNAKE_CASE				(     self :      List[str]   ,					UpperCAmelCase__ :      Tuple=None   ,					UpperCAmelCase__ :      Any=None   ,					UpperCAmelCase__ :      int=""   ,					**UpperCAmelCase__ :      Any)		->int:





           '''simple docstring'''

           A__ 					=       tokenizer_kwargs

           A__ 					=       {}
           if hasattr(self.model.config   ,					'''return_all_scores''') and return_all_scores is None:
                  A__ 					=       self.model.config.return_all_scores

           if isinstance(UpperCAmelCase__   ,					UpperCAmelCase__) or top_k is None:
                  A__ 					=       top_k
                  A__ 					=       False
           elif return_all_scores is not None:
                  warnings.warn(
                      '''`return_all_scores` is now deprecated,  if want a similar functionality use `top_k=None` instead of'''
                      ''' `return_all_scores=True` or `top_k=1` instead of `return_all_scores=False`.'''   ,					UpperCAmelCase__   ,					)
                  if return_all_scores:
                         A__ 					=       None
                  else:
                         A__ 					=       1

           if isinstance(UpperCAmelCase__   ,					UpperCAmelCase__):
                  A__ 					=       ClassificationFunction[function_to_apply.upper()]

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


    def __call__(     self :      str   ,					*UpperCAmelCase__ :      List[Any]   ,					**UpperCAmelCase__ :      Optional[int])		->Union[str, Any]:





           '''simple docstring'''

           A__ 					=       super().__call__(*UpperCAmelCase__   ,					**UpperCAmelCase__)
           # TODO try and retrieve it in a nicer way from _sanitize_parameters.
           A__ 					=       '''top_k''' not in kwargs
           if isinstance(args[0]   ,					UpperCAmelCase__) and _legacy:
                  # This pipeline is odd, and return a list when single item is run
                  return [result]
           else:
                  return result


    def 			SCREAMING_SNAKE_CASE				(     self :      Tuple   ,					UpperCAmelCase__ :      Any   ,					**UpperCAmelCase__ :      str)		->Dict[str, GenericTensor]:





           '''simple docstring'''

           A__ 					=       self.framework
           if isinstance(UpperCAmelCase__   ,					UpperCAmelCase__):
                  return self.tokenizer(**UpperCAmelCase__   ,					return_tensors=UpperCAmelCase__   ,					**UpperCAmelCase__)
           elif isinstance(UpperCAmelCase__   ,					UpperCAmelCase__) and len(UpperCAmelCase__) == 1 and isinstance(inputs[0]   ,					UpperCAmelCase__) and len(inputs[0]) == 2:
                  # It used to be valid to use a list of list of list for text pairs, keeping this path for BC
                  return self.tokenizer(
                      text=inputs[0][0]   ,					text_pair=inputs[0][1]   ,					return_tensors=UpperCAmelCase__   ,					**UpperCAmelCase__)
           elif isinstance(UpperCAmelCase__   ,					UpperCAmelCase__):
                  # This is likely an invalid usage of the pipeline attempting to pass text pairs.
                  raise ValueError(
                      '''The pipeline received invalid inputs, if you are trying to send text pairs, you can try to send a'''
                      ''' dictionary `{"text": "My text", "text_pair": "My pair"}` in order to send a text pair.''')
           return self.tokenizer(UpperCAmelCase__   ,					return_tensors=UpperCAmelCase__   ,					**UpperCAmelCase__)


    def 			SCREAMING_SNAKE_CASE				(     self :      List[str]   ,					UpperCAmelCase__ :      Tuple)		->Tuple:





           '''simple docstring'''

           return self.model(**UpperCAmelCase__)





    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[Any]   ,					UpperCAmelCase__ :      int   ,					UpperCAmelCase__ :      Optional[int]=None   ,					UpperCAmelCase__ :      List[Any]=1   ,					UpperCAmelCase__ :      str=True)		->Dict:





           '''simple docstring'''

           if function_to_apply is None:
                  if self.model.config.problem_type == "multi_label_classification" or self.model.config.num_labels == 1:
                         A__ 					=       ClassificationFunction.SIGMOID
                  elif self.model.config.problem_type == "single_label_classification" or self.model.config.num_labels > 1:
                         A__ 					=       ClassificationFunction.SOFTMAX
                  elif hasattr(self.model.config   ,					'''function_to_apply''') and function_to_apply is None:
                         A__ 					=       self.model.config.function_to_apply
                  else:
                         A__ 					=       ClassificationFunction.NONE

           A__ 					=       model_outputs['''logits'''][0]
           A__ 					=       outputs.numpy()

           if function_to_apply == ClassificationFunction.SIGMOID:
                  A__ 					=       sigmoid(UpperCAmelCase__)
           elif function_to_apply == ClassificationFunction.SOFTMAX:
                  A__ 					=       softmax(UpperCAmelCase__)
           elif function_to_apply == ClassificationFunction.NONE:
                  A__ 					=       outputs
           else:
                  raise ValueError(f"""Unrecognized `function_to_apply` argument: {function_to_apply}""")

           if top_k == 1 and _legacy:
                  return {"label": self.model.config.idalabel[scores.argmax().item()], "score": scores.max().item()}

           A__ 					=       [
               {'''label''': self.model.config.idalabel[i], '''score''': score.item()} for i, score in enumerate(UpperCAmelCase__)
           ]
           if not _legacy:
                  dict_scores.sort(key=lambda UpperCAmelCase__: x["score"]   ,					reverse=UpperCAmelCase__)
                  if top_k is not None:
                         A__ 					=       dict_scores[:top_k]
           return dict_scores


