



from pickle import UnpicklingError

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

from ..utils import logging


lowerCamelCase__	=       logging.get_logger(__name__)

def      lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE				:	List[Any] ,   _SCREAMING_SNAKE_CASE				:	Union[str, Any]			):
				"""simple docstring"""







				try:
								with open(lowerCamelCase__ ,   """rb"""			) as flax_state_f:
												__a        =						from_bytes(lowerCamelCase__ ,   flax_state_f.read()			)
				except UnpicklingError as e:
								try:
												with open(lowerCamelCase__			) as f:
																if f.read().startswith("""version"""			):
																				raise OSError(
																				    """You seem to have cloned a repository without having git-lfs installed. Please"""
																				    """ install git-lfs and run `git lfs install` followed by `git lfs pull` in the"""
																				    """ folder you cloned."""			)
																else:
																				raise ValueError from e
								except (UnicodeDecodeError, ValueError):
												raise EnvironmentError(f"Unable to convert {model_file} to Flax deserializable object. "			)

				return load_flax_weights_in_pytorch_model(lowerCamelCase__ ,   lowerCamelCase__			)

def      lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE				:	Any ,   _SCREAMING_SNAKE_CASE				:	Dict			):
				"""simple docstring"""







				try:
								import torch  # noqa: F401
				except ImportError:
								logger.error(
								    """Loading 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
				__a        =						flatten_dict(jax.tree_util.tree_map(lambda _SCREAMING_SNAKE_CASE			: x.dtype == jnp.bfloataa ,   lowerCamelCase__			)			).values()
				if any(lowerCamelCase__			):
								# convert all weights to fp32 if they 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."""			)
								__a        =						jax.tree_util.tree_map(
								    lambda _SCREAMING_SNAKE_CASE			: params.astype(np.floataa			) if params.dtype == jnp.bfloataa else params ,   lowerCamelCase__			)

				__a        =						""""""

				__a        =						flatten_dict(lowerCamelCase__ ,   sep="""."""			)
				__a        =						pt_model.state_dict()

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

				for flax_key_tuple, flax_tensor in flax_state_dict.items():
								__a        =						flax_key_tuple.split("""."""			)

								if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4:
												__a        =						flax_key_tuple_array[:-1] + ["""weight"""]
												__a        =						jnp.transpose(lowerCamelCase__ ,   (3, 2, 0, 1)			)
								elif flax_key_tuple_array[-1] == "kernel":
												__a        =						flax_key_tuple_array[:-1] + ["""weight"""]
												__a        =						flax_tensor.T
								elif flax_key_tuple_array[-1] == "scale":
												__a        =						flax_key_tuple_array[:-1] + ["""weight"""]

								if "time_embedding" not in flax_key_tuple_array:
												for i, flax_key_tuple_string in enumerate(lowerCamelCase__			):
																__a        =						(
																    flax_key_tuple_string.replace("""_0""" ,   """.0"""			)
																    .replace("""_1""" ,   """.1"""			)
																    .replace("""_2""" ,   """.2"""			)
																    .replace("""_3""" ,   """.3"""			)
																    .replace("""_4""" ,   """.4"""			)
																    .replace("""_5""" ,   """.5"""			)
																    .replace("""_6""" ,   """.6"""			)
																    .replace("""_7""" ,   """.7"""			)
																    .replace("""_8""" ,   """.8"""			)
																    .replace("""_9""" ,   """.9"""			)
																)

								__a        =						""".""".join(lowerCamelCase__			)

								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
																__a        =						np.asarray(lowerCamelCase__			) if not isinstance(lowerCamelCase__ ,   np.ndarray			) else flax_tensor
																__a        =						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
				__a        =						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)."""			)
				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."""			)

				return pt_model





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


lowerCamelCase							:Tuple				    =					logging.get_logger(__name__)







class 	_lowerCAmelCase							(			__UpperCAmelCase ):


	def     _a	(self       ,      lowercase							):
				if isinstance(lowercase       ,      lowercase							):
							A_	:						Tuple	=     [label.strip() for label in labels.split(""","""							) if label.strip()]
				return labels


	def __call__(self       ,      lowercase       ,      lowercase       ,      lowercase							):
				if len(lowercase							) == 0 or len(lowercase							) == 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(lowercase							)							)

				if isinstance(lowercase       ,      lowercase							):
							A_	:						Optional[Any]	=     [sequences]

				A_	:						List[Any]	=     []
				for sequence in sequences:
							sequence_pairs.extend([[sequence, hypothesis_template.format(lowercase							)] for label in labels]							)

				return sequence_pairs, sequences







@add_end_docstrings(__UpperCAmelCase )
class 	_lowerCAmelCase							(			__UpperCAmelCase ):


	def __init__(self       ,      lowercase=ZeroShotClassificationArgumentHandler()       ,      *lowercase       ,      **lowercase							):
				A_	:						str	=     args_parser
				super().__init__(*lowercase       ,      **lowercase							)
				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     _a	(self							):
				for label, ind in self.model.config.labelaid.items():
							if label.lower().startswith("""entail"""							):
										return ind
				return -1


	def     _a	(self       ,      lowercase       ,      lowercase=True       ,      lowercase=True       ,      lowercase=TruncationStrategy.ONLY_FIRST       ,      **lowercase							):
				A_	:						Optional[int]	=     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`"""							)
							A_	:						Any	=     self.tokenizer.eos_token
				try:
							A_	:						Optional[Any]	=     self.tokenizer(
							    lowercase       ,      add_special_tokens=lowercase       ,      return_tensors=lowercase       ,      padding=lowercase       ,      truncation=lowercase       ,      )
				except Exception as e:
							if "too short" in str(lowercase							):
										# 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.

										A_	:						str	=     self.tokenizer(
										    lowercase       ,      add_special_tokens=lowercase       ,      return_tensors=lowercase       ,      padding=lowercase       ,      truncation=TruncationStrategy.DO_NOT_TRUNCATE       ,      )
							else:
										raise e

				return inputs


	def     _a	(self       ,      **lowercase							):
				if kwargs.get("""multi_class"""       ,      lowercase							) is not None:
							A_	:						Union[str, Any]	=     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."""							)
				A_	:						Tuple	=     {}
				if "candidate_labels" in kwargs:
							A_	:						Optional[int]	=     self._args_parser._parse_labels(kwargs["""candidate_labels"""]							)
				if "hypothesis_template" in kwargs:
							A_	:						List[str]	=     kwargs["""hypothesis_template"""]

				A_	:						Union[str, Any]	=     {}
				if "multi_label" in kwargs:
							A_	:						Optional[int]	=     kwargs["""multi_label"""]
				return preprocess_params, {}, postprocess_params


	def __call__(self       ,      lowercase       ,      *lowercase       ,      **lowercase       ,      ):
				if len(lowercase							) == 0:
							pass
				elif len(lowercase							) == 1 and "candidate_labels" not in kwargs:
							A_	:						Any	=     args[0]
				else:
							raise ValueError(F'Unable to understand extra arguments {args}'							)

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


	def     _a	(self       ,      lowercase       ,      lowercase=None       ,      lowercase="This example is {}."							):
				A_,    A_	:						Any	=     self._args_parser(lowercase       ,      lowercase       ,      lowercase							)

				for i, (candidate_label, sequence_pair) in enumerate(zip(lowercase       ,      lowercase							)							):
							A_	:						List[Any]	=     self._parse_and_tokenize([sequence_pair]							)

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


	def     _a	(self       ,      lowercase							):
				A_	:						Dict	=     inputs["""candidate_label"""]
				A_	:						Any	=     inputs["""sequence"""]
				A_	:						List[Any]	=     {k: inputs[k] for k in self.tokenizer.model_input_names}
				A_	:						Optional[int]	=     self.model(**lowercase							)

				A_	:						Optional[Any]	=     {
				    """candidate_label""": candidate_label,
				    """sequence""": sequence,
				    """is_last""": inputs["""is_last"""],
				    **outputs,
				}
				return model_outputs


	def     _a	(self       ,      lowercase       ,      lowercase=False							):
				A_	:						Tuple	=     [outputs["""candidate_label"""] for outputs in model_outputs]
				A_	:						Optional[int]	=     [outputs["""sequence"""] for outputs in model_outputs]
				A_	:						Union[str, Any]	=     np.concatenate([output["""logits"""].numpy() for output in model_outputs]							)
				A_	:						List[str]	=     logits.shape[0]
				A_	:						Optional[int]	=     len(lowercase							)
				A_	:						int	=     N // n
				A_	:						int	=     logits.reshape((num_sequences, n, -1)							)

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

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