o ॵi÷Pã@süddlmZddlmZmZmZmZddlZddl m Z edZ eGdd„de ƒƒZ eGdd „d e ƒƒZ eGd d „d e ƒƒZeGd d „d e ƒƒZeGdd„de ƒƒZeGdd„de ƒƒZeGdd„deƒƒZeGdd„de ƒƒZeGdd„de ƒƒZeGdd„de ƒƒZeGdd„deƒƒZeGdd„de ƒƒZeGdd„de ƒƒZeGd d!„d!e ƒƒZeGd"d#„d#eƒƒZeGd$d%„d%e ƒƒZeGd&d'„d'e ƒƒZeGd(d)„d)eƒƒZeGd*d+„d+e ƒƒZeGd,d-„d-e ƒƒZeGd.d/„d/e ƒƒZ eGd0d1„d1e ƒƒZ!dS)2é)Ú dataclass)ÚListÚOptionalÚTupleÚUnionN)ÚModelOutputBase)z torch.Tensorz tf.Tensorc@ó6eZdZUdZdZeed<dZeed<dZeed<dS)ÚBackboneModelOutputa·The output class for text classification models. Args: last_hidden_state (`Tensor`, *optional*): Sequence of hidden-states at the output of the last layer of the model. pooler_output (`Tensor`, *optional*) The tensor of the pooled hidden state. hidden_states (`Tensor`, *optional*) Hidden-states of the model at the output of each layer plus the optional initial embedding outputs. NÚlast_hidden_stateÚ pooler_outputÚ hidden_states) Ú__name__Ú __module__Ú __qualname__Ú__doc__r ÚTensorÚ__annotations__r r ©rrúR/home/ubuntu/.local/lib/python3.10/site-packages/modelscope/outputs/nlp_outputs.pyr s  r c@r)ÚAttentionBackboneModelOutputa‡The output class for backbones of attention based models. Args: attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`): Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, sequence_length)`. Attentions weights after the attention softmax, used to compute the weighted average in the self-attention heads. cross_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` and `config.add_cross_attention=True` is passed or when `config.output_attentions=True`): Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, sequence_length)`. Attentions weights of the decoder's cross-attention layer, after the attention softmax, used to compute the weighted average in the cross-attention heads. past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`): Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and optionally if `config.is_encoder_decoder=True` 2 additional tensors of shape `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`. Contains pre-computed hidden-states (key and values in the self-attention blocks and optionally if `config.is_encoder_decoder=True` in the cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding. NÚ attentionsÚpast_key_valuesÚcross_attentions) r rrrrrrrrrrrrrs  # rc@sªeZdZUdZdZeed<dZee e eed<dZ ee eed<dZ ee eed<dZ ee eed<dZ eeed<dZee eed <dZee eed <dS) ÚSeq2SeqModelOutputaÁ Base class for model encoder's outputs that also contains : pre-computed hidden states that can speed up sequential decoding. Args: last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`): Sequence of hidden-states at the output of the last layer of the decoder of the model. If `past_key_values` is used only the last hidden-state of the sequences of shape `(batch_size, 1, hidden_size)` is output. past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`): Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`. Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding. decoder_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`): Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the decoder at the output of each layer plus the optional initial embedding outputs. decoder_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`): Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, sequence_length)`. Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the self-attention heads. cross_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`): Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, sequence_length)`. Attentions weights of the decoder's cross-attention layer, after the attention softmax, used to compute the weighted average in the cross-attention heads. encoder_last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*): Sequence of hidden-states at the output of the last layer of the encoder of the model. encoder_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`): Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the encoder at the output of each layer plus the optional initial embedding outputs. encoder_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`): Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, sequence_length)`. Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the self-attention heads. Nr rÚdecoder_hidden_statesÚdecoder_attentionsrÚencoder_last_hidden_stateÚencoder_hidden_statesÚencoder_attentions)r rrrr rrrrrrrrrrrrrrrrFs  Hrc@óBeZdZUdZdZeed<dZeed<dZeed<dZ eed<dS)ÚFaqQuestionAnsweringOutputz(The output class for faq QA models. NÚscoresÚlabelsÚlossÚlogits) r rrrr!rrr"r#r$rrrrr šs    r c@óeZdZUdZdZeed<dS)ÚFeatureExtractionOutputz4The output class for feature extraction models. NÚtext_embedding)r rrrr'rrrrrrr&¥ó r&c@r)ÚFillMaskModelOutputa³The output class for fill mask models. Args: logits (`Tensor`): The logits output of the model. loss (`Tensor`, *optional*) The loss of the model, available when training. input_ids (`Tensor`, *optional*) The input id tensor fed into the model. hidden_states (`Tensor`, *optional*) Hidden-states of the model at the output of each layer plus the optional initial embedding outputs. Nr$r#Ú input_idsr ) r rrrr$rrr#r*r rrrrr)­s   r)c@r%)ÚAttentionFillMaskModelOutputaThe output class for the fill mask and attention based models. Args: attentions (`tuple(Tensor)`, *optional* Attentions weights after the attention softmax, used to compute the weighted average in the self-attention heads. Nr)r rrrrrrrrrrr+¿s r+c@ó eZdZUdZdZejed<dS)ÚInformationExtractionOutputú8The output class for information extraction models. NÚspo_list)r rrrr/ÚnpÚndarrayrrrrrr-Ëó r-c@sºeZdZUdZdZeeed<dZeed<dZ ee e eed<dZ ee eed<dZ ee eed<dZ ee eed<dZeeed <dZee eed <dZee eed <dS) ÚSeq2SeqLMOutputal Base class for sequence-to-sequence language models outputs. Args: loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided): Language modeling loss. logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`): Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax). past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`): Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`. Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding. decoder_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`): Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the decoder at the output of each layer plus the initial embedding outputs. decoder_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`): Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, sequence_length)`. Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the self-attention heads. cross_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`): Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, sequence_length)`. Attentions weights of the decoder's cross-attention layer, after the attention softmax, used to compute the weighted average in the cross-attention heads. encoder_last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*): Sequence of hidden-states at the output of the last layer of the encoder of the model. encoder_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`): Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the encoder at the output of each layer plus the initial embedding outputs. encoder_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`): Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, sequence_length)`. Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the self-attention heads. Nr#r$rrrrrrr)r rrrr#rrrr$rrrrrrrrrrrrr3Ós G r3c@ó*eZdZUdZdZeed<dZeed<dS)ÚTextClassificationModelOutputahThe output class for text classification models. Args: logits (`Tensor`): The logits output of the model. loss (`Tensor`, *optional*) The loss of the model, available when training. hidden_states (`Tensor`, *optional*) Hidden-states of the model at the output of each layer plus the optional initial embedding outputs. Nr$r#©r rrrr$rrr#rrrrr5'ó  r5c@r)Ú&AttentionTextClassificationModelOutputzûThe output class for backbones of attention based models. Args: attentions (`tuple(Tensor)`, *optional* Attentions weights after the attention softmax, used to compute the weighted average in the self-attention heads. Nrr r© r rrrrrrr rrrrrr86s   r8c@r,)ÚTextErrorCorrectionOutputr.NÚ predictions)r rrrr;r0r1rrrrrr:Dr2r:c@r%)ÚWordAlignmentOutputz0The output class for word alignment models. Nr;)r rrrr;rrrrrrr<Lr(r<c@r4)ÚTextGenerationModelOutputadThe output class for text generation models. Args: logits (`Tensor`): The logits output of the model. loss (`Tensor`, *optional*) The loss of the model, available when training. hidden_states (`Tensor`, *optional*) Hidden-states of the model at the output of each layer plus the optional initial embedding outputs. Nr$r#r6rrrrr=Tr7r=c@r)Ú"AttentionTextGenerationModelOutputawThe output class for text generation of attention based models. Args: logits (`Tensor`): The logits output of the model. loss (`Tensor`, *optional*) The loss of the model, available when training. hidden_states (`Tensor`, *optional*) Hidden-states of the model at the output of each layer plus the optional initial embedding outputs. Nrr rr9rrrrr>có   r>c@sbeZdZUdZdZeed<dZee eed<dZ ee e eed<dZ ee e eed<dS)ÚTokenGeneratorOutputa— The output class for generate method of text generation models. Args: sequences (`torch.LongTensor` of shape `(batch_size*num_return_sequences, sequence_length)`): The generated sequences. The second dimension (sequence_length) is either equal to `max_length` or shorter if all batches finished early due to the `eos_token_id`. scores (`tuple(torch.FloatTensor)` *optional*, returned when `output_scores=True` is passed or when `config.output_scores=True`): Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax) at each generation step. Tuple of `torch.FloatTensor` with up to `max_new_tokens` elements (one element for each generated token), with each tensor of shape `(batch_size*num_return_sequences, config.vocab_size)`. attentions (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `output_attentions=True` is passed or `config.output_attentions=True`): Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of `torch.FloatTensor` of shape `(num_return_sequences*batch_size, num_heads, generated_length, sequence_length)`. hidden_states (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`): Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of `torch.FloatTensor` of shape `(num_return_sequences*batch_size, generated_length, hidden_size)`. NÚ sequencesr!rr ) r rrrrArrr!rrrr rrrrr@rs  r@c@sNeZdZUdZdZeed<dZeed<dZeed<dZ eed<dZ eed<dS)ÚTokenClassificationModelOutputaMThe output class for token classification models. logits (`Tensor`): The logits output of the model. loss (`Tensor`, *optional*) The loss of the model, available when training. predictions: A PyTorch tensor of the best tag sequence for each batch of shape (nbest, batch_size, seq_length) offset_mapping (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): Indices of positions of each input sequence tokens in the sentence. Selected in the range ``[0, sequence_length - 1]``. Nr$r#Úoffset_mappingr;Ú label_mask) r rrrr$rrr#rCr;rDrrrrrB’s    rBc@r4)Ú'AttentionTokenClassificationModelOutputzóThe output class for backbones of attention based models. Args: attentions (`tuple(Tensor)`, *optional* Attentions weights after the attention softmax, used to compute the weighted average in the self-attention heads. Nrr )r rrrrrrr rrrrrE¦s  rEc@r%)Ú-DialogueUserSatisfactionEstimationModelOutputz}The output class for user satisfaction estimation. Args: logits (`Tensor`): The logits output of the model. Nr$)r rrrr$rrrrrrrF²s rFc@r)ÚSentencEmbeddingModelOutputa<The output class for text classification models. Args: query_embs (`Tensor`, *optional*): The tensor of the query embeddings. doc_embs (`Tensor`, *optional*) Then tensor of the doc embeddings. loss (`torch.FloatTensor` of shape `(1,)`, *optional*): Sentence Embedding modeling loss. NÚquery_embeddingsÚdoc_embeddingsr#) r rrrrHrrrIr#rrrrrG¼r?rGc@s:eZdZUdZdZeed<dZeed<dZe e ed<dS)ÚTranslationEvaluationOutputz8The output class for translation evaluation models. NÚscorer#Ú input_format) r rrrrKrrr#rLrÚstrrrrrrJËs   rJc@sreZdZUdZdZeeed<dZeeed<dZ eed<dZ ee eed<dZ ee eed<dZ eed<dS) Ú!MachineReadingComprehensionOutputa.The output class for machine reading comprehension models. Args: loss (`Tensor`, *optional*): The training loss of the current batch match_loss (`Tensor`, *optinal*): The match loss of the current batch span_logits (`Tensor`): The logits of the span matrix output by the model hidden_states (`Tuple[Tensor]`, *optinal*): The hidden states output by the model attentions (`Tuple[Tensor]`, *optinal*): The attention scores output by the model input_ids (`Tensor`): The token ids of the input sentence Nr#Ú match_lossÚ span_logitsr rr*)r rrrr#rrrrOrPr rrr*rrrrrNÕs   rN)"Ú dataclassesrÚtypingrrrrÚnumpyr0Úmodelscope.outputs.outputsrrr rrr r&r)r+r-r3r5r8r:r<r=r>r@rBrErFrGrJrNrrrrÚsb  )S  S