



"""simple docstring"""






from typing import List, Union

import numpy as np

from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, logging
from .base import PIPELINE_INIT_ARGS, ArgumentHandler, ChunkPipeline


_lowercase			:			List[Any]										=						logging.get_logger(__name__)

class 	__SCREAMING_SNAKE_CASE     (				lowerCAmelCase_       ):


					'''simple docstring'''





					def 		snake_case	(	self							:  Any,  lowerCamelCase							:  int					)-> Optional[Any]:
								if isinstance(lowerCamelCase,  lowerCamelCase					):
											lowerCamelCase__		:		Union[str, Any]		     =[label.strip() for label in labels.split(''','''					) if label.strip()]
								return labels




					def __call__(	self							:  Union[str, Any],  lowerCamelCase							:  Dict,  lowerCamelCase							:  Any,  lowerCamelCase							:  Optional[Any]					)-> Optional[int]:
								if len(lowerCamelCase					) == 0 or len(lowerCamelCase					) == 0:
											raise ValueError('''You must include at least one label and at least one sequence.'''					)
								if hypothesis_template.format(labels[0]					) == hypothesis_template:
											raise ValueError(
											    (
											        '''The provided hypothesis_template "{}" was not able to be formatted with the target labels. '''
											        '''Make sure the passed template includes formatting syntax such as {{}} where the label should go.'''
											    ).format(lowerCamelCase					)					)

								if isinstance(lowerCamelCase,  lowerCamelCase					):
											lowerCamelCase__		:		Tuple		     =[sequences]

								lowerCamelCase__		:		Any		     =[]
								for sequence in sequences:
											sequence_pairs.extend([[sequence, hypothesis_template.format(lowerCamelCase					)] for label in labels]					)

								return sequence_pairs, sequences





@add_end_docstrings(lowerCAmelCase_       )
class 	__SCREAMING_SNAKE_CASE     (				lowerCAmelCase_       ):


					'''simple docstring'''





					def __init__(	self							:  List[str],  lowerCamelCase							:  Optional[Any]=ZeroShotClassificationArgumentHandler(),  *lowerCamelCase							:  Tuple,  **lowerCamelCase							:  List[str]					)-> int:
								lowerCamelCase__		:		Optional[Any]		     =args_parser
								super().__init__(*lowerCamelCase,  **lowerCamelCase					)
								if self.entailment_id == -1:
											logger.warning(
											    '''Failed to determine \'entailment\' label id from the label2id mapping in the model config. Setting to '''
											    '''-1. Define a descriptive label2id mapping in the model config to ensure correct outputs.'''					)



					@property
					def 		snake_case	(	self							:  List[Any]					)-> Union[str, Any]:
								for label, ind in self.model.config.labelaid.items():
											if label.lower().startswith('''entail'''					):
														return ind
								return -1



					def 		snake_case	(	self							:  Optional[int],  lowerCamelCase							:  int,  lowerCamelCase							:  Any=True,  lowerCamelCase							:  List[str]=True,  lowerCamelCase							:  int=TruncationStrategy.ONLY_FIRST,  **lowerCamelCase							:  List[Any]					)-> List[str]:
								lowerCamelCase__		:		Tuple		     =self.framework
								if self.tokenizer.pad_token is None:
											# Override for tokenizers not supporting padding
											logger.error(
											    '''Tokenizer was not supporting padding necessary for zero-shot, attempting to use '''
											    ''' `pad_token=eos_token`'''					)
											lowerCamelCase__		:		Any		     =self.tokenizer.eos_token
								try:
											lowerCamelCase__		:		Tuple		     =self.tokenizer(
											    lowerCamelCase,  add_special_tokens=lowerCamelCase,  return_tensors=lowerCamelCase,  padding=lowerCamelCase,  truncation=lowerCamelCase,  )
								except Exception as e:
											if "too short" in str(lowerCamelCase					):
														# tokenizers might yell that we want to truncate
														# to a value that is not even reached by the input.
														# In that case we don't want to truncate.
														# It seems there's not a really better way to catch that
														# exception.

														lowerCamelCase__		:		List[Any]		     =self.tokenizer(
														    lowerCamelCase,  add_special_tokens=lowerCamelCase,  return_tensors=lowerCamelCase,  padding=lowerCamelCase,  truncation=TruncationStrategy.DO_NOT_TRUNCATE,  )
											else:
														raise e

								return inputs



					def 		snake_case	(	self							:  int,  **lowerCamelCase							:  Tuple					)-> Any:
								if kwargs.get('''multi_class''',  lowerCamelCase					) is not None:
											lowerCamelCase__		:		Optional[int]		     =kwargs['''multi_class''']
											logger.warning(
											    '''The `multi_class` argument has been deprecated and renamed to `multi_label`. '''
											    '''`multi_class` will be removed in a future version of Transformers.'''					)
								lowerCamelCase__		:		Any		     ={}
								if "candidate_labels" in kwargs:
											lowerCamelCase__		:		Dict		     =self._args_parser._parse_labels(kwargs['''candidate_labels''']					)
								if "hypothesis_template" in kwargs:
											lowerCamelCase__		:		Optional[Any]		     =kwargs['''hypothesis_template''']

								lowerCamelCase__		:		str		     ={}
								if "multi_label" in kwargs:
											lowerCamelCase__		:		Optional[Any]		     =kwargs['''multi_label''']
								return preprocess_params, {}, postprocess_params



					def __call__(	self							:  List[str],  lowerCamelCase							:  Union[str, List[str]],  *lowerCamelCase							:  Union[str, Any],  **lowerCamelCase							:  int,  )-> Union[str, Any]:
								if len(lowerCamelCase					) == 0:
											pass
								elif len(lowerCamelCase					) == 1 and "candidate_labels" not in kwargs:
											lowerCamelCase__		:		int		     =args[0]
								else:
											raise ValueError(F'''Unable to understand extra arguments {args}'''					)

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



					def 		snake_case	(	self							:  Any,  lowerCamelCase							:  List[str],  lowerCamelCase							:  Any=None,  lowerCamelCase							:  Optional[Any]="This example is {}."					)-> Tuple:
								lowerCamelCase__     ,       lowerCamelCase__		:		List[str]		     =self._args_parser(lowerCamelCase,  lowerCamelCase,  lowerCamelCase					)

								for i, (candidate_label, sequence_pair) in enumerate(zip(lowerCamelCase,  lowerCamelCase					)					):
											lowerCamelCase__		:		Optional[Any]		     =self._parse_and_tokenize([sequence_pair]					)

											yield {
											    "candidate_label": candidate_label,
											    "sequence": sequences[0],
											    "is_last": i == len(lowerCamelCase					) - 1,
											    **model_input,
											}



					def 		snake_case	(	self							:  Optional[int],  lowerCamelCase							:  Optional[int]					)-> Union[str, Any]:
								lowerCamelCase__		:		Dict		     =inputs['''candidate_label''']
								lowerCamelCase__		:		Union[str, Any]		     =inputs['''sequence''']
								lowerCamelCase__		:		Any		     ={k: inputs[k] for k in self.tokenizer.model_input_names}
								lowerCamelCase__		:		Optional[Any]		     =self.model(**lowerCamelCase					)

								lowerCamelCase__		:		Union[str, Any]		     ={
								    '''candidate_label''': candidate_label,
								    '''sequence''': sequence,
								    '''is_last''': inputs['''is_last'''],
								    **outputs,
								}
								return model_outputs




					def 		snake_case	(	self							:  Union[str, Any],  lowerCamelCase							:  Tuple,  lowerCamelCase							:  Any=False					)-> Union[str, Any]:
								lowerCamelCase__		:		Optional[Any]		     =[outputs['''candidate_label'''] for outputs in model_outputs]
								lowerCamelCase__		:		Tuple		     =[outputs['''sequence'''] for outputs in model_outputs]
								lowerCamelCase__		:		Union[str, Any]		     =np.concatenate([output['''logits'''].numpy() for output in model_outputs]					)
								lowerCamelCase__		:		Dict		     =logits.shape[0]
								lowerCamelCase__		:		str		     =len(lowerCamelCase					)
								lowerCamelCase__		:		List[str]		     =N // n
								lowerCamelCase__		:		Any		     =logits.reshape((num_sequences, n, -1)					)

								if multi_label or len(lowerCamelCase					) == 1:
											# softmax over the entailment vs. contradiction dim for each label independently
											lowerCamelCase__		:		Tuple		     =self.entailment_id
											lowerCamelCase__		:		Optional[int]		     =-1 if entailment_id == 0 else 0
											lowerCamelCase__		:		Union[str, Any]		     =reshaped_outputs[..., [contradiction_id, entailment_id]]
											lowerCamelCase__		:		List[str]		     =np.exp(lowerCamelCase					) / np.exp(lowerCamelCase					).sum(-1,  keepdims=lowerCamelCase					)
											lowerCamelCase__		:		Tuple		     =scores[..., 1]
								else:
											# softmax the "entailment" logits over all candidate labels
											lowerCamelCase__		:		int		     =reshaped_outputs[..., self.entailment_id]
											lowerCamelCase__		:		List[Any]		     =np.exp(lowerCamelCase					) / np.exp(lowerCamelCase					).sum(-1,  keepdims=lowerCamelCase					)

								lowerCamelCase__		:		List[Any]		     =list(reversed(scores[0].argsort()					)					)
								return {
								    "sequence": sequences[0],
								    "labels": [candidate_labels[i] for i in top_inds],
								    "scores": scores[0, top_inds].tolist(),
								}









"""simple docstring"""






from typing import List, Optional, Union

import numpy as np
import tensorflow as tf

from .utils import logging


_lowercase			:			List[str]										=						logging.get_logger(__name__)






def 					snake_case__       (		__lowerCamelCase    :   Union[tf.Tensor, np.ndarray]     ):
			"""simple docstring"""
			if isinstance(__lowerCamelCase							,		np.ndarray     ):
						return list(tensor.shape     )

			lowerCamelCase__		:		List[Any]		     =tf.shape(__lowerCamelCase     )

			if tensor.shape == tf.TensorShape(__lowerCamelCase     ):
						return dynamic

			lowerCamelCase__		:		List[str]		     =tensor.shape.as_list()

			return [dynamic[i] if s is None else s for i, s in enumerate(__lowerCamelCase     )]






def 					snake_case__       (		__lowerCamelCase    :   tf.Tensor							,		__lowerCamelCase    :   Optional[int] = None							,		__lowerCamelCase    :   Optional[str] = None     ):
			"""simple docstring"""
			return tf.nn.softmax(logits=logits + 1e-9							,		axis=__lowerCamelCase							,		name=__lowerCamelCase     )






def 					snake_case__       (		__lowerCamelCase    :   Optional[Any]							,		__lowerCamelCase    :   str							,		__lowerCamelCase    :   Optional[int]							,		__lowerCamelCase    :   Any=1e-5							,		__lowerCamelCase    :   str=-1     ):
			"""simple docstring"""
			# This is a very simplified functional layernorm, designed to duplicate
			# the functionality of PyTorch nn.functional.layer_norm when this is needed to port
			# models in Transformers.

			if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(__lowerCamelCase							,		__lowerCamelCase     ):
						raise NotImplementedError('''Only 1D weight and bias tensors are supported for now, with only a single axis.'''     )

			# Get mean and variance on the axis to be normalized
			lowerCamelCase__     ,       lowerCamelCase__		:		Optional[int]		     =tf.nn.moments(__lowerCamelCase							,		axes=[axis]							,		keepdims=__lowerCamelCase     )

			if axis != -1:
						# Reshape scale and weight to have the same rank as inputs, but with 1 dimensions
						# on every dimension except axis
						lowerCamelCase__		:		Optional[Any]		     =[1] * inputs.shape.rank
						lowerCamelCase__		:		Union[str, Any]		     =shape_list(__lowerCamelCase     )[axis]
						lowerCamelCase__		:		Optional[Any]		     =tf.reshape(__lowerCamelCase							,		__lowerCamelCase     )
						lowerCamelCase__		:		Any		     =tf.reshape(__lowerCamelCase							,		__lowerCamelCase     )

			# Compute layer normalization using the batch_normalization
			# function.
			lowerCamelCase__		:		List[str]		     =tf.nn.batch_normalization(
			    __lowerCamelCase							,		__lowerCamelCase							,		__lowerCamelCase							,		offset=__lowerCamelCase							,		scale=__lowerCamelCase							,		variance_epsilon=__lowerCamelCase							,		)
			return outputs






def 					snake_case__       (		__lowerCamelCase    :   Any							,		__lowerCamelCase    :   List[Any]=0							,		__lowerCamelCase    :   int=-1     ):
			"""simple docstring"""
			# Replicates the behavior of torch.flatten in TF

			# If end_dim or start_dim is negative, count them from the end
			if end_dim < 0:
						end_dim += input.shape.rank
			if start_dim < 0:
						start_dim += input.shape.rank

			if start_dim == end_dim:
						return input

			lowerCamelCase__		:		Optional[int]		     =tf.shape(__lowerCamelCase     )
			lowerCamelCase__		:		Optional[int]		     =tf.math.reduce_prod(in_shape[start_dim : end_dim + 1]     )
			lowerCamelCase__		:		List[Any]		     =tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]]							,		axis=0     )
			return tf.reshape(__lowerCamelCase							,		__lowerCamelCase     )






def 					snake_case__       (		__lowerCamelCase    :   tf.Tensor     ):
			"""simple docstring"""
			if not isinstance(__lowerCamelCase							,		tf.Tensor     ):
						lowerCamelCase__		:		List[Any]		     =tf.convert_to_tensor(__lowerCamelCase     )  # Catches stray NumPy inputs
			if encoder_attention_mask.shape.rank == 3:
						lowerCamelCase__		:		int		     =encoder_attention_mask[:, None, :, :]
			if encoder_attention_mask.shape.rank == 2:
						lowerCamelCase__		:		int		     =encoder_attention_mask[:, None, None, :]
			# T5 has a mask that can compare sequence ids, we can simulate this here with this transposition
			# Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow
			# /transformer/transformer_layers.py#L270
			# encoder_extended_attention_mask = (encoder_extended_attention_mask ==
			# encoder_extended_attention_mask.transpose(-1, -2))
			lowerCamelCase__		:		str		     =(
			    tf.cast(1							,		encoder_attention_mask.dtype     ) - encoder_extended_attention_mask
			) * encoder_extended_attention_mask.dtype.min

			return encoder_extended_attention_mask






def 					snake_case__       (		__lowerCamelCase    :   tf.Tensor							,		__lowerCamelCase    :   int							,		__lowerCamelCase    :   str = "input_ids"     ):
			"""simple docstring"""
			tf.debugging.assert_less(
			    __lowerCamelCase							,		tf.cast(__lowerCamelCase							,		dtype=tensor.dtype     )							,		message=(
			        f'''The maximum value of {tensor_name} ({tf.math.reduce_max(__lowerCamelCase     )}) must be smaller than the embedding '''
			        f'''layer\'s input dimension ({embed_dim}). The likely cause is some problem at tokenization time.'''
			    )							,		)






def 					snake_case__       (		__lowerCamelCase    :   Tuple							,		__lowerCamelCase    :   List[str]							,		__lowerCamelCase    :   Dict     ):
			"""simple docstring"""
			lowerCamelCase__		:		Any		     =64512
			# Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT`
			# because in that case even chunking the array would not make the saving
			# possible.
			lowerCamelCase__		:		Tuple		     =[x for x in data if len(__lowerCamelCase     ) > HDF5_OBJECT_HEADER_LIMIT]

			# Expecting this to never be true.
			if bad_attributes:
						raise RuntimeError(
						    '''The following attributes cannot be saved to HDF5 file because '''
						    f'''they are larger than {HDF5_OBJECT_HEADER_LIMIT} '''
						    f'''bytes: {bad_attributes}'''     )

			lowerCamelCase__		:		Optional[Any]		     =np.asarray(__lowerCamelCase     )

			lowerCamelCase__		:		str		     =1
			lowerCamelCase__		:		List[Any]		     =np.array_split(__lowerCamelCase							,		__lowerCamelCase     )

			# This will never loop forever thanks to the test above.
			while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data     ):
						num_chunks += 1
						lowerCamelCase__		:		Union[str, Any]		     =np.array_split(__lowerCamelCase							,		__lowerCamelCase     )

			if num_chunks > 1:
						for chunk_id, chunk_data in enumerate(__lowerCamelCase     ):
									lowerCamelCase__		:		List[str]		     =chunk_data
			else:
						lowerCamelCase__		:		Dict		     =data






def 					snake_case__       (		__lowerCamelCase    :   Dict							,		__lowerCamelCase    :   Optional[Any]     ):
			"""simple docstring"""
			if name in group.attrs:
						lowerCamelCase__		:		Optional[int]		     =[n.decode('''utf8'''     ) if hasattr(__lowerCamelCase							,		'''decode'''     ) else n for n in group.attrs[name]]
			else:
						lowerCamelCase__		:		str		     =[]
						lowerCamelCase__		:		str		     =0
						while "%s%d" % (name, chunk_id) in group.attrs:
									data.extend(
									    [n.decode('''utf8'''     ) if hasattr(__lowerCamelCase							,		'''decode'''     ) else n for n in group.attrs['''%s%d''' % (name, chunk_id)]]     )
									chunk_id += 1
			return data






def 					snake_case__       (		__lowerCamelCase    :   Dict     ):
			"""simple docstring"""

			def _expand_single_ad_tensor(__lowerCamelCase    :   List[Any]     ):
						if isinstance(__lowerCamelCase							,		tf.Tensor     ) and t.shape.rank == 1:
									return tf.expand_dims(__lowerCamelCase							,		axis=-1     )
						return t

			return tf.nest.map_structure(_expand_single_ad_tensor							,		__lowerCamelCase     )




