


'''simple docstring'''







import inspect
from typing import Callable, List, Optional, Set, Tuple, Union

import torch
from packaging import version
from safetensors.torch import storage_ptr, storage_size
from torch import nn

from .utils import logging


A   :  List[Any]       		=				[nn.LayerNorm]

A   :  Tuple       		=				logging.get_logger(__name__)

A   :  Any       		=				version.parse(version.parse(torch.__version__).base_version)

A   :  Dict       		=				parsed_torch_version_base >= version.parse('''2.0''')
A   :  str       		=				parsed_torch_version_base >= version.parse('''1.12''')
A   :  Tuple       		=				parsed_torch_version_base >= version.parse('''1.11''')
A   :  Tuple       		=				parsed_torch_version_base < version.parse('''1.11''')






def    lowerCAmelCase__ (       lowerCamelCase  :    List[str]						,lowerCamelCase  :    Dict						,lowerCamelCase  :    Optional[Any]						,lowerCamelCase  :    int						,self  :    Tuple     ):
       from torch import _softmax_backward_data

       if is_torch_less_than_1_11:
              return _softmax_backward_data(lowerCamelCase						,lowerCamelCase						,parent.dim						,self     )
       else:
              return _softmax_backward_data(lowerCamelCase						,lowerCamelCase						,parent.dim						,self.dtype     )






def    lowerCAmelCase__ (       lowerCamelCase  :    nn.Linear						,lowerCamelCase  :    torch.LongTensor						,lowerCamelCase  :    int = 0     ):
       _A  :			Optional[Any]											=      index.to(layer.weight.device     )
       _A  :			List[str]											=      layer.weight.index_select(lowerCamelCase						,lowerCamelCase     ).clone().detach()
       if layer.bias is not None:
              if dim == 1:
                     _A  :			Optional[Any]											=      layer.bias.clone().detach()
              else:
                     _A  :			Union[str, Any]											=      layer.bias[index].clone().detach()
       _A  :			str											=      list(layer.weight.size()     )
       _A  :			List[str]											=      len(lowerCamelCase     )
       _A  :			Tuple											=      nn.Linear(new_size[1]						,new_size[0]						,bias=layer.bias is not None     ).to(layer.weight.device     )
       _A  :			Dict											=      False
       new_layer.weight.copy_(W.contiguous()     )
       _A  :			int											=      True
       if layer.bias is not None:
              _A  :			List[Any]											=      False
              new_layer.bias.copy_(b.contiguous()     )
              _A  :			Dict											=      True
       return new_layer


class 				__lowerCamelCase				( nn.Module ):
    """simple docstring"""


    def __init__(						self    :							int   ,							SCREAMING_SNAKE_CASE    :							str   ,							SCREAMING_SNAKE_CASE    :							int):
           super().__init__()
           _A  :			Union[str, Any]											=      nf
           _A  :			Any											=      nn.Parameter(torch.empty(SCREAMING_SNAKE_CASE   ,							SCREAMING_SNAKE_CASE))
           _A  :			str											=      nn.Parameter(torch.zeros(SCREAMING_SNAKE_CASE))
           nn.init.normal_(self.weight   ,							std=0.02)


    def      A					(						self    :							Optional[int]   ,							SCREAMING_SNAKE_CASE    :							Any):
           _A  :			str											=      x.size()[:-1] + (self.nf,)
           _A  :			int											=      torch.addmm(self.bias   ,							x.view(-1   ,							x.size(-1))   ,							self.weight)
           _A  :			Any											=      x.view(SCREAMING_SNAKE_CASE)
           return x






def    lowerCAmelCase__ (       lowerCamelCase  :    ConvaD						,lowerCamelCase  :    torch.LongTensor						,lowerCamelCase  :    int = 1     ):
       _A  :			Optional[int]											=      index.to(layer.weight.device     )
       _A  :			List[str]											=      layer.weight.index_select(lowerCamelCase						,lowerCamelCase     ).clone().detach()
       if dim == 0:
              _A  :			List[str]											=      layer.bias.clone().detach()
       else:
              _A  :			str											=      layer.bias[index].clone().detach()
       _A  :			str											=      list(layer.weight.size()     )
       _A  :			Union[str, Any]											=      len(lowerCamelCase     )
       _A  :			str											=      ConvaD(new_size[1]						,new_size[0]     ).to(layer.weight.device     )
       _A  :			str											=      False
       new_layer.weight.copy_(W.contiguous()     )
       _A  :			str											=      True
       _A  :			str											=      False
       new_layer.bias.copy_(b.contiguous()     )
       _A  :			Any											=      True
       return new_layer






def    lowerCAmelCase__ (       lowerCamelCase  :    Union[nn.Linear, ConvaD]						,lowerCamelCase  :    torch.LongTensor						,lowerCamelCase  :    Optional[int] = None     ):
       if isinstance(lowerCamelCase						,nn.Linear     ):
              return prune_linear_layer(lowerCamelCase						,lowerCamelCase						,dim=0 if dim is None else dim     )
       elif isinstance(lowerCamelCase						,lowerCamelCase     ):
              return prune_convad_layer(lowerCamelCase						,lowerCamelCase						,dim=1 if dim is None else dim     )
       else:
              raise ValueError(F'Can\'t prune layer of class {layer.__class__}'     )






def    lowerCAmelCase__ (       lowerCamelCase  :    Callable[..., torch.Tensor]						,lowerCamelCase  :    int						,lowerCamelCase  :    int						,*lowerCamelCase  :    Tuple     ):
       assert len(lowerCamelCase     ) > 0, F'{input_tensors} has to be a tuple/list of tensors'

       # inspect.signature exist since python 3.5 and is a python method -> no problem with backward compatibility
       _A  :			Optional[int]											=      len(inspect.signature(lowerCamelCase     ).parameters     )
       if num_args_in_forward_chunk_fn != len(lowerCamelCase     ):
              raise ValueError(
                  F'forward_chunk_fn expects {num_args_in_forward_chunk_fn} arguments, but only {len(lowerCamelCase     )} input '
                  'tensors are given'     )

       if chunk_size > 0:
              _A  :			List[str]											=      input_tensors[0].shape[chunk_dim]
              for input_tensor in input_tensors:
                     if input_tensor.shape[chunk_dim] != tensor_shape:
                            raise ValueError(
                                F'All input tenors have to be of the same shape: {tensor_shape}, '
                                F'found shape {input_tensor.shape[chunk_dim]}'     )

              if input_tensors[0].shape[chunk_dim] % chunk_size != 0:
                     raise ValueError(
                         F'The dimension to be chunked {input_tensors[0].shape[chunk_dim]} has to be a multiple of the chunk '
                         F'size {chunk_size}'     )

              _A  :			List[str]											=      input_tensors[0].shape[chunk_dim] // chunk_size

              # chunk input tensor into tuples
              _A  :			Tuple											=      tuple(input_tensor.chunk(lowerCamelCase						,dim=lowerCamelCase     ) for input_tensor in input_tensors     )
              # apply forward fn to every tuple
              _A  :			Optional[Any]											=      tuple(forward_fn(*lowerCamelCase     ) for input_tensors_chunk in zip(*lowerCamelCase     )     )
              # concatenate output at same dimension
              return torch.cat(lowerCamelCase						,dim=lowerCamelCase     )

       return forward_fn(*lowerCamelCase     )






def    lowerCAmelCase__ (       lowerCamelCase  :    List[int]						,lowerCamelCase  :    int						,lowerCamelCase  :    int						,lowerCamelCase  :    Set[int]     ):
       _A  :			List[str]											=      torch.ones(lowerCamelCase						,lowerCamelCase     )
       _A  :			Any											=      set(lowerCamelCase     ) - already_pruned_heads  # Convert to set and remove already pruned heads
       for head in heads:
              # Compute how many pruned heads are before the head and move the index accordingly
              _A  :			int											=      head - sum(1 if h < head else 0 for h in already_pruned_heads     )
              _A  :			int											=      0
       _A  :			Optional[int]											=      mask.view(-1     ).contiguous().eq(1     )
       _A  :			torch.LongTensor											=      torch.arange(len(lowerCamelCase     )     )[mask].long()
       return heads, index






def    lowerCAmelCase__ (       *lowerCamelCase  :    Union[torch.Tensor, List[torch.Tensor]]						,lowerCamelCase  :    Optional[str] = None     ):
       return torch.meshgrid(*lowerCamelCase						,indexing=lowerCamelCase     )






def    lowerCAmelCase__ (       lowerCamelCase  :    torch.Tensor     ):
       return tensor.device, storage_ptr(lowerCamelCase     ), storage_size(lowerCamelCase     )










'''simple docstring'''







import unittest

from transformers import (
    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    SummarizationPipeline,
    TFPreTrainedModel,
    pipeline,
)
from transformers.testing_utils import get_gpu_count, is_pipeline_test, require_tf, require_torch, slow, torch_device
from transformers.tokenization_utils import TruncationStrategy

from .test_pipelines_common import ANY


A   :  Optional[Any]       		=				-1 if torch_device == '''cpu''' else 0


@is_pipeline_test
class 				__lowerCamelCase				( unittest.TestCase ):
    """simple docstring"""
    a									=					MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
    a									=					TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING


    def      A					(						self    :							Union[str, Any]   ,							SCREAMING_SNAKE_CASE    :							Tuple   ,							SCREAMING_SNAKE_CASE    :							Optional[Any]   ,							SCREAMING_SNAKE_CASE    :							Dict):
           _A  :			str											=      SummarizationPipeline(model=SCREAMING_SNAKE_CASE   ,							tokenizer=SCREAMING_SNAKE_CASE)
           return summarizer, ["(CNN)The Palestinian Authority officially became", "Some other text"]


    def      A					(						self    :							Optional[int]   ,							SCREAMING_SNAKE_CASE    :							Tuple   ,							SCREAMING_SNAKE_CASE    :							Optional[int]):
           _A  :			str											=      summarizer.model

           _A  :			Tuple											=      summarizer('(CNN)The Palestinian Authority officially became')
           self.assertEqual(SCREAMING_SNAKE_CASE   ,							[{'summary_text': ANY(SCREAMING_SNAKE_CASE)}])

           _A  :			Optional[Any]											=      summarizer(
               '(CNN)The Palestinian Authority officially became '   ,							num_beams=2   ,							min_length=2   ,							max_length=5   ,							)
           self.assertEqual(SCREAMING_SNAKE_CASE   ,							[{'summary_text': ANY(SCREAMING_SNAKE_CASE)}])

           # Some models (Switch Transformers, LED, T5, LongT5, etc) can handle long sequences.
           _A  :			Union[str, Any]											=      [
               'SwitchTransformersConfig',
               'T5Config',
               'LongT5Config',
               'LEDConfig',
               'PegasusXConfig',
               'FSMTConfig',
               'M2M100Config',
               'ProphetNetConfig',  # positional embeddings up to a fixed maximum size (otherwise clamping the values)
           ]
           if model.config.__class__.__name__ not in model_can_handle_longer_seq:
                  # Too long and exception is expected.
                  # For TF models, if the weights are initialized in GPU context, we won't get expected index error from
                  # the embedding layer.
                  if not (
                      isinstance(SCREAMING_SNAKE_CASE   ,							SCREAMING_SNAKE_CASE)
                      and get_gpu_count() > 0
                      and len(summarizer.model.trainable_weights) > 0
                  ):
                         with self.assertRaises(SCREAMING_SNAKE_CASE):
                                _A  :			Any											=      summarizer('This ' * 1000)
           _A  :			int											=      summarizer('This ' * 1000   ,							truncation=TruncationStrategy.ONLY_FIRST)


    @require_torch
    def      A					(						self    :							int):
           _A  :			Tuple											=      pipeline(task='summarization'   ,							model='sshleifer/tiny-mbart'   ,							framework='pt')
           _A  :			List[str]											=      summarizer('This is a small test')
           self.assertEqual(
               SCREAMING_SNAKE_CASE   ,							[
                   {
                       'summary_text': 'เข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไป'
                   }
               ]   ,							)


    @require_tf
    def      A					(						self    :							int):
           _A  :			Optional[Any]											=      pipeline(task='summarization'   ,							model='sshleifer/tiny-mbart'   ,							framework='tf')
           _A  :			Any											=      summarizer('This is a small test')
           self.assertEqual(
               SCREAMING_SNAKE_CASE   ,							[
                   {
                       'summary_text': 'เข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไป'
                   }
               ]   ,							)


    @require_torch
    @slow
    def      A					(						self    :							List[Any]):
           _A  :			int											=      pipeline(task='summarization'   ,							device=SCREAMING_SNAKE_CASE)
           _A  :			int											=      (
               ' (CNN)The Palestinian Authority officially became the 123rd member of the International Criminal Court on'
               ' Wednesday, a step that gives the court jurisdiction over alleged crimes in Palestinian territories. The'
               ' formal accession was marked with a ceremony at The Hague, in the Netherlands, where the court is based.'
               ' The Palestinians signed the ICC\'s founding Rome Statute in January, when they also accepted its'
               ' jurisdiction over alleged crimes committed "in the occupied Palestinian territory, including East'
               ' Jerusalem, since June 13, 2014." Later that month, the ICC opened a preliminary examination into the'
               ' situation in Palestinian territories, paving the way for possible war crimes investigations against'
               ' Israelis. As members of the court, Palestinians may be subject to counter-charges as well. Israel and'
               ' the United States, neither of which is an ICC member, opposed the Palestinians\' efforts to join the'
               ' body. But Palestinian Foreign Minister Riad al-Malki, speaking at Wednesday\'s ceremony, said it was a'
               ' move toward greater justice. "As Palestine formally becomes a State Party to the Rome Statute today, the'
               ' world is also a step closer to ending a long era of impunity and injustice," he said, according to an'
               ' ICC news release. "Indeed, today brings us closer to our shared goals of justice and peace." Judge'
               ' Kuniko Ozaki, a vice president of the ICC, said acceding to the treaty was just the first step for the'
               ' Palestinians. "As the Rome Statute today enters into force for the State of Palestine, Palestine'
               ' acquires all the rights as well as responsibilities that come with being a State Party to the Statute.'
               ' These are substantive commitments, which cannot be taken lightly," she said. Rights group Human Rights'
               ' Watch welcomed the development. "Governments seeking to penalize Palestine for joining the ICC should'
               ' immediately end their pressure, and countries that support universal acceptance of the court\'s treaty'
               ' should speak out to welcome its membership," said Balkees Jarrah, international justice counsel for the'
               ' group. \"What\'s objectionable is the attempts to undermine international justice, not Palestine\'s'
               ' decision to join a treaty to which over 100 countries around the world are members." In January, when'
               ' the preliminary ICC examination was opened, Israeli Prime Minister Benjamin Netanyahu described it as an'
               ' outrage, saying the court was overstepping its boundaries. The United States also said it "strongly"'
               ' disagreed with the court\'s decision. \"As we have said repeatedly, we do not believe that Palestine is a'
               ' state and therefore we do not believe that it is eligible to join the ICC," the State Department said in'
               ' a statement. It urged the warring sides to resolve their differences through direct negotiations. "We'
               ' will continue to oppose actions against Israel at the ICC as counterproductive to the cause of peace,"'
               ' it said. But the ICC begs to differ with the definition of a state for its purposes and refers to the'
               ' territories as "Palestine." While a preliminary examination is not a formal investigation, it allows the'
               ' court to review evidence and determine whether to investigate suspects on both sides. Prosecutor Fatou'
               ' Bensouda said her office would "conduct its analysis in full independence and impartiality." The war'
               ' between Israel and Hamas militants in Gaza last summer left more than 2,000 people dead. The inquiry'
               ' will include alleged war crimes committed since June. The International Criminal Court was set up in'
               ' 2002 to prosecute genocide, crimes against humanity and war crimes. CNN\'s Vasco Cotovio, Kareem Khadder'
               ' and Faith Karimi contributed to this report.'
           )
           _A  :			Optional[Any]											=      (
               ' The Palestinian Authority becomes the 123rd member of the International Criminal Court . The move gives'
               ' the court jurisdiction over alleged crimes in Palestinian territories . Israel and the United States'
               ' opposed the Palestinians\' efforts to join the court . Rights group Human Rights Watch welcomes the move,'
               ' says governments seeking to penalize Palestine should end pressure .'
           )
           _A  :			Union[str, Any]											=      summarizer(SCREAMING_SNAKE_CASE)
           self.assertEqual(result[0]['summary_text']   ,							SCREAMING_SNAKE_CASE)






