

'''simple docstring'''







import enum
import warnings

from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_tf_available():
      import tensorflow as tf

      from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

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

__lowerCamelCase		       =    logging.get_logger(__name__)


class 					A__      (      enum.Enum			):
    lowercase						=		0
    lowercase						=		1


@add_end_docstrings(_snake_case			)
class 					A__      (      _snake_case			):
    lowercase						=		"generated"



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





           '''simple docstring'''
           super().__init__(*UpperCamelCase__		,				**UpperCamelCase__       )

           self.check_model_type(
               TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
               if self.framework == """tf"""
               else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING       )



    def 					snake_case_			(					self		,				UpperCamelCase__=None		,				UpperCamelCase__=None		,				UpperCamelCase__=None		,				UpperCamelCase__=None		,				UpperCamelCase__=None		,				UpperCamelCase__=None		,				**UpperCamelCase__		,				)						->      Union[str, Any]:





           '''simple docstring'''
           A_						=      {}
           if truncation is not None:
                  A_						=      truncation

           A_						=      generate_kwargs

           A_						=      {}
           if return_tensors is not None and return_type is None:
                  A_						=      ReturnType.TENSORS if return_tensors else ReturnType.TEXT
           if return_type is not None:
                  A_						=      return_type

           if clean_up_tokenization_spaces is not None:
                  A_						=      clean_up_tokenization_spaces

           if stop_sequence is not None:
                  A_						=      self.tokenizer.encode(UpperCamelCase__		,				add_special_tokens=UpperCamelCase__       )
                  if len(UpperCamelCase__       ) > 1:
                         warnings.warn(
                             """Stopping on a multiple token sequence is not yet supported on transformers. The first token of"""
                             """ the stop sequence will be used as the stop sequence string in the interim."""       )
                  A_						=      stop_sequence_ids[0]

           return preprocess_params, forward_params, postprocess_params



    def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           return True



    def 					snake_case_			(					self		,				*UpperCamelCase__		,				UpperCamelCase__       )						->      Optional[int]:





           '''simple docstring'''
           A_						=      self.model.config.prefix if self.model.config.prefix is not None else """"""
           if isinstance(args[0]		,				UpperCamelCase__       ):
                  if self.tokenizer.pad_token_id is None:
                         raise ValueError("""Please make sure that the tokenizer has a pad_token_id when using a batch input"""       )
                  A_						=      ([prefix + arg for arg in args[0]],)
                  A_						=      True

           elif isinstance(args[0]		,				UpperCamelCase__       ):
                  A_						=      (prefix + args[0],)
                  A_						=      False
           else:
                  raise ValueError(
                      f''' `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`'''       )
           A_						=      self.tokenizer(*UpperCamelCase__		,				padding=UpperCamelCase__		,				truncation=UpperCamelCase__		,				return_tensors=self.framework       )
           # This is produced by tokenizers but is an invalid generate kwargs
           if "token_type_ids" in inputs:
                  del inputs["token_type_ids"]
           return inputs



    def __call__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           A_						=      super().__call__(*UpperCamelCase__		,				**UpperCamelCase__       )
           if (
               isinstance(args[0]		,				UpperCamelCase__       )
               and all(isinstance(UpperCamelCase__		,				UpperCamelCase__       ) for el in args[0]       )
               and all(len(UpperCamelCase__       ) == 1 for res in result       )
           ):
                  return [res[0] for res in result]
           return result



    def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__=TruncationStrategy.DO_NOT_TRUNCATE		,				**UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           A_						=      self._parse_and_tokenize(UpperCamelCase__		,				truncation=UpperCamelCase__		,				**UpperCamelCase__       )
           return inputs



    def 					snake_case_			(					self		,				UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           if self.framework == "pt":
                  A_					,			A_						=      model_inputs["""input_ids"""].shape
           elif self.framework == "tf":
                  A_					,			A_						=      tf.shape(model_inputs["""input_ids"""]       ).numpy()

           A_						=      generate_kwargs.get("""min_length"""		,				self.model.config.min_length       )
           A_						=      generate_kwargs.get("""max_length"""		,				self.model.config.max_length       )
           self.check_inputs(UpperCamelCase__		,				generate_kwargs["""min_length"""]		,				generate_kwargs["""max_length"""]       )
           A_						=      self.model.generate(**UpperCamelCase__		,				**UpperCamelCase__       )
           A_						=      output_ids.shape[0]
           if self.framework == "pt":
                  A_						=      output_ids.reshape(UpperCamelCase__		,				out_b // in_b		,				*output_ids.shape[1:]       )
           elif self.framework == "tf":
                  A_						=      tf.reshape(UpperCamelCase__		,				(in_b, out_b // in_b, *output_ids.shape[1:])       )
           return {"output_ids": output_ids}







    def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__=ReturnType.TEXT		,				UpperCamelCase__=False       )						->      Optional[int]:





           '''simple docstring'''
           A_						=      []
           for output_ids in model_outputs["output_ids"][0]:
                  if return_type == ReturnType.TENSORS:
                         A_						=      {f'''{self.return_name}_token_ids''': output_ids}
                  elif return_type == ReturnType.TEXT:
                         A_						=      {
                             f'''{self.return_name}_text''': self.tokenizer.decode(
                                 UpperCamelCase__		,				skip_special_tokens=UpperCamelCase__		,				clean_up_tokenization_spaces=UpperCamelCase__		,				)
                         }
                  records.append(UpperCamelCase__       )
           return records


@add_end_docstrings(_snake_case			)
class 					A__      (      _snake_case			):
    lowercase						=		"summary"



    def __call__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Optional[Any]:





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







    def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )						->      bool:





           '''simple docstring'''
           if max_length < min_length:
                  logger.warning(f'''Your min_length={min_length} must be inferior than your max_length={max_length}.'''       )

           if input_length < max_length:
                  logger.warning(
                      f'''Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is '''
                      """a summarization task, where outputs shorter than the input are typically wanted, you might """
                      f'''consider decreasing max_length manually, e.g. summarizer(\'...\', max_length={input_length//2})'''       )


@add_end_docstrings(_snake_case			)
class 					A__      (      _snake_case			):
    lowercase						=		"translation"



    def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )						->      int:





           '''simple docstring'''
           if input_length > 0.9 * max_length:
                  logger.warning(
                      f'''Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider '''
                      """increasing your max_length manually, e.g. translator('...', max_length=400)"""       )
           return True



    def 					snake_case_			(					self		,				*UpperCamelCase__		,				UpperCamelCase__=TruncationStrategy.DO_NOT_TRUNCATE		,				UpperCamelCase__=None		,				UpperCamelCase__=None       )						->      int:





           '''simple docstring'''
           if getattr(self.tokenizer		,				"""_build_translation_inputs"""		,				UpperCamelCase__       ):
                  return self.tokenizer._build_translation_inputs(
                      *UpperCamelCase__		,				return_tensors=self.framework		,				truncation=UpperCamelCase__		,				src_lang=UpperCamelCase__		,				tgt_lang=UpperCamelCase__       )
           else:
                  return super()._parse_and_tokenize(*UpperCamelCase__		,				truncation=UpperCamelCase__       )



    def 					snake_case_			(					self		,				UpperCamelCase__=None		,				UpperCamelCase__=None		,				**UpperCamelCase__       )						->      Any:





           '''simple docstring'''
           A_					,			A_					,			A_						=      super()._sanitize_parameters(**UpperCamelCase__       )
           if src_lang is not None:
                  A_						=      src_lang
           if tgt_lang is not None:
                  A_						=      tgt_lang
           if src_lang is None and tgt_lang is None:
                  # Backward compatibility, direct arguments use is preferred.
                  A_						=      kwargs.get("""task"""		,				self.task       )
                  A_						=      task.split("""_"""       )
                  if task and len(UpperCamelCase__       ) == 4:
                         # translation, XX, to YY
                         A_						=      items[1]
                         A_						=      items[3]
           return preprocess_params, forward_params, postprocess_params







    def __call__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





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



'''simple docstring'''







import tensorflow as tf

from ...tf_utils import shape_list


class 					A__      (      tf.keras.layers.Layer			):



    def __init__(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__=1		,				UpperCamelCase__=False		,				**UpperCamelCase__       )						->      Union[str, Any]:





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

           A_						=      vocab_size
           A_						=      d_embed
           A_						=      d_proj

           A_						=      cutoffs + [vocab_size]
           A_						=      [0] + self.cutoffs
           A_						=      div_val

           A_						=      self.cutoffs[0]
           A_						=      len(self.cutoffs       ) - 1
           A_						=      self.shortlist_size + self.n_clusters
           A_						=      keep_order

           A_						=      []
           A_						=      []



    def 					snake_case_			(					self		,				UpperCamelCase__       )						->      Union[str, Any]:





           '''simple docstring'''
           if self.n_clusters > 0:
                  A_						=      self.add_weight(
                      shape=(self.n_clusters, self.d_embed)		,				initializer="""zeros"""		,				trainable=UpperCamelCase__		,				name="""cluster_weight"""       )
                  A_						=      self.add_weight(
                      shape=(self.n_clusters,)		,				initializer="""zeros"""		,				trainable=UpperCamelCase__		,				name="""cluster_bias"""       )

           if self.div_val == 1:
                  for i in range(len(self.cutoffs       )       ):
                         if self.d_proj != self.d_embed:
                                A_						=      self.add_weight(
                                    shape=(self.d_embed, self.d_proj)		,				initializer="""zeros"""		,				trainable=UpperCamelCase__		,				name=f'''out_projs_._{i}'''		,				)
                                self.out_projs.append(UpperCamelCase__       )
                         else:
                                self.out_projs.append(UpperCamelCase__       )
                         A_						=      self.add_weight(
                             shape=(self.vocab_size, self.d_embed)		,				initializer="""zeros"""		,				trainable=UpperCamelCase__		,				name=f'''out_layers_._{i}_._weight'''		,				)
                         A_						=      self.add_weight(
                             shape=(self.vocab_size,)		,				initializer="""zeros"""		,				trainable=UpperCamelCase__		,				name=f'''out_layers_._{i}_._bias'''		,				)
                         self.out_layers.append((weight, bias)       )
           else:
                  for i in range(len(self.cutoffs       )       ):
                         A_					,			A_						=      self.cutoff_ends[i], self.cutoff_ends[i + 1]
                         A_						=      self.d_embed // (self.div_val**i)

                         A_						=      self.add_weight(
                             shape=(d_emb_i, self.d_proj)		,				initializer="""zeros"""		,				trainable=UpperCamelCase__		,				name=f'''out_projs_._{i}'''       )
                         self.out_projs.append(UpperCamelCase__       )
                         A_						=      self.add_weight(
                             shape=(r_idx - l_idx, d_emb_i)		,				initializer="""zeros"""		,				trainable=UpperCamelCase__		,				name=f'''out_layers_._{i}_._weight'''		,				)
                         A_						=      self.add_weight(
                             shape=(r_idx - l_idx,)		,				initializer="""zeros"""		,				trainable=UpperCamelCase__		,				name=f'''out_layers_._{i}_._bias'''		,				)
                         self.out_layers.append((weight, bias)       )
           super().build(UpperCamelCase__       )



    @staticmethod
    def 					snake_case_			(					UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__=None       )						->      List[Any]:





           '''simple docstring'''
           A_						=      x
           if proj is not None:
                  A_						=      tf.einsum("""ibd,ed->ibe"""		,				UpperCamelCase__		,				UpperCamelCase__       )
           return tf.einsum("""ibd,nd->ibn"""		,				UpperCamelCase__		,				UpperCamelCase__       ) + b



    @staticmethod
    def 					snake_case_			(					UpperCamelCase__		,				UpperCamelCase__       )						->      List[str]:





           '''simple docstring'''
           A_						=      shape_list(UpperCamelCase__       )
           A_						=      tf.range(lp_size[0]		,				dtype=target.dtype       )
           A_						=      tf.stack([r, target]		,				1       )
           return tf.gather_nd(UpperCamelCase__		,				UpperCamelCase__       )







    def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__=True		,				UpperCamelCase__=False       )						->      Optional[int]:





           '''simple docstring'''
           A_						=      0
           if self.n_clusters == 0:
                  A_						=      self._logit(UpperCamelCase__		,				self.out_layers[0][0]		,				self.out_layers[0][1]		,				self.out_projs[0]       )
                  if target is not None:
                         A_						=      tf.nn.sparse_softmax_cross_entropy_with_logits(labels=UpperCamelCase__		,				logits=UpperCamelCase__       )
                  A_						=      tf.nn.log_softmax(UpperCamelCase__		,				axis=-1       )
           else:
                  A_						=      shape_list(UpperCamelCase__       )
                  A_						=      []
                  A_						=      tf.zeros(hidden_sizes[:2]       )
                  for i in range(len(self.cutoffs       )       ):
                         A_					,			A_						=      self.cutoff_ends[i], self.cutoff_ends[i + 1]
                         if target is not None:
                                A_						=      (target >= l_idx) & (target < r_idx)
                                A_						=      tf.where(UpperCamelCase__       )
                                A_						=      tf.boolean_mask(UpperCamelCase__		,				UpperCamelCase__       ) - l_idx

                         if self.div_val == 1:
                                A_						=      self.out_layers[0][0][l_idx:r_idx]
                                A_						=      self.out_layers[0][1][l_idx:r_idx]
                         else:
                                A_						=      self.out_layers[i][0]
                                A_						=      self.out_layers[i][1]

                         if i == 0:
                                A_						=      tf.concat([cur_W, self.cluster_weight]		,				0       )
                                A_						=      tf.concat([cur_b, self.cluster_bias]		,				0       )

                                A_						=      self._logit(UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				self.out_projs[0]       )
                                A_						=      tf.nn.log_softmax(UpperCamelCase__       )
                                out.append(head_logprob[..., : self.cutoffs[0]]       )
                                if target is not None:
                                       A_						=      tf.boolean_mask(UpperCamelCase__		,				UpperCamelCase__       )
                                       A_						=      self._gather_logprob(UpperCamelCase__		,				UpperCamelCase__       )
                         else:
                                A_						=      self._logit(UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				self.out_projs[i]       )
                                A_						=      tf.nn.log_softmax(UpperCamelCase__       )
                                A_						=      self.cutoffs[0] + i - 1  # No probability for the head cluster
                                A_						=      head_logprob[..., cluster_prob_idx, None] + tail_logprob
                                out.append(UpperCamelCase__       )
                                if target is not None:
                                       A_						=      tf.boolean_mask(UpperCamelCase__		,				UpperCamelCase__       )
                                       A_						=      tf.boolean_mask(UpperCamelCase__		,				UpperCamelCase__       )
                                       A_						=      self._gather_logprob(UpperCamelCase__		,				UpperCamelCase__       )
                                       cur_logprob += cur_head_logprob[:, self.cutoff_ends[1] + i - 1]
                         if target is not None:
                                loss += tf.scatter_nd(UpperCamelCase__		,				-cur_logprob		,				shape_list(UpperCamelCase__       )       )
                  A_						=      tf.concat(UpperCamelCase__		,				axis=-1       )

           if target is not None:
                  if return_mean:
                         A_						=      tf.reduce_mean(UpperCamelCase__       )
                  # Add the training-time loss value to the layer using `self.add_loss()`.
                  self.add_loss(UpperCamelCase__       )

                  # Log the loss as a metric (we could log arbitrary metrics,
                  # including different metrics for training and inference.
                  self.add_metric(UpperCamelCase__		,				name=self.name		,				aggregation="""mean""" if return_mean else """"""       )

           return out
