9iPSSKJr SSKJrJrJrJr SSKrSSK J r \Sr \"SS\ 55r \"SS \ 55r \"S S \ 55r\"S S \ 55r\"SS\ 55r\"SS\ 55r\"SS\55r\"SS\ 55r\"SS\ 55r\"SS\ 55r\"SS\55r\"SS\ 55r\"SS\ 55r\"S S!\ 55r\"S"S#\55r\"S$S%\ 55r\"S&S'\ 55r\"S(S)\55r\"S*S+\ 55r\"S,S-\ 55r\"S.S/\ 55r \"S0S1\ 55r!g)2) dataclass)ListOptionalTupleUnionN)ModelOutputBase)z torch.Tensorz tf.TensorcD\rSrSr%SrSr\\S'Sr\\S'Sr \\S'Sr g)BackboneModelOutput aThe 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. Nlast_hidden_state pooler_output hidden_states) __name__ __module__ __qualname____firstlineno____doc__r Tensor__annotations__r r__static_attributes__r^/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/modelscope/outputs/nlp_outputs.pyr r s(!%v$ M6  M6 rr cD\rSrSr%SrSr\\S'Sr\\S'Sr \\S'Sr g)AttentionBackboneModelOutputaThe 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 attentionspast_key_valuescross_attentionsr) rrrrrrrrrrrrrrrrs)"FJ"OV"#f#rrc\rSrSr%SrSr\\S'Sr\ \ \ \\S'Sr \ \ \\S'Sr \ \ \\S'Sr \ \ \\S'Sr\ \\S 'Sr\ \ \\S 'Sr\ \ \\S 'S rg) Seq2SeqModelOutputFa 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 rdecoder_hidden_statesdecoder_attentionsrencoder_last_hidden_stateencoder_hidden_statesencoder_attentionsr)rrrrrr rrrrrr#r$rr%r&r'rrrrr!r!FsFP!%v$6:OXeE&M23:598E&M2926v/604huV}-426x/6598E&M2926v/6rr!cR\rSrSr%SrSr\\S'Sr\\S'Sr \\S'Sr \\S'Sr g) FaqQuestionAnsweringOutputz(The output class for faq QA models. Nscoreslabelslosslogitsr) rrrrrr+rrr,r-r.rrrrr)r)s1FFFFD&FFrr)c(\rSrSr%SrSr\\S'Srg)FeatureExtractionOutputz4The output class for feature extraction models. Ntext_embeddingr) rrrrrr2rrrrrrr0r0s"NF!rr0cR\rSrSr%SrSr\\S'Sr\\S'Sr \\S'Sr \\S'Sr g) FillMaskModelOutputaThe 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_idsrr) rrrrrr.rrr-r6rrrrrr4r4s1FFD&Iv M6 rr4c(\rSrSr%SrSr\\S'Srg)AttentionFillMaskModelOutputzThe 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. Nrr) rrrrrrrrrrrrr8r8sJrr8c<\rSrSr%SrSr\R\S'Sr g)InformationExtractionOutput8The output class for information extraction models. Nspo_listr) rrrrrr>npndarrayrrrrrr;r;s Hbjjrr;c\rSrSr%SrSr\\\S'Sr \\S'Sr \\ \ \\S'Sr \\ \\S'Sr \\ \\S'Sr\\ \\S 'Sr\\\S 'Sr\\ \\S 'Sr\\ \\S 'S rg)Seq2SeqLMOutputat 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.rr#r$rr%r&r'r)rrrrrr-rrrr.rrr#r$rr%r&r'rrrrrBrBsEN"D(6 !FF6:OXeE&M23:598E&M2926v/604huV}-426x/6598E&M2926v/6rrBc6\rSrSr%SrSr\\S'Sr\\S'Sr g)TextClassificationModelOutputi'aPThe 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 rrrrrr.rrr-rrrrrErE'FFD&rrEcD\rSrSr%SrSr\\S'Sr\\S'Sr \\S'Sr g)&AttentionTextClassificationModelOutputi6zThe 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. Nrrrr rrrrrrrrrrrrrrrIrI6s'J M6 "OV"rrIc(\rSrSr%SrSr\\S'Srg)TextErrorCorrectionOutputiDr=N predictionsr rrrrrrMrrrrrrrLrLDKrrLc(\rSrSr%SrSr\\S'Srg)WordAlignmentOutputiLz0The output class for word alignment models. NrMrrNrrrrQrQLrOrrQc6\rSrSr%SrSr\\S'Sr\\S'Sr g)TextGenerationModelOutputiTaLThe 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-rrFrrrrSrSTrGrrScD\rSrSr%SrSr\\S'Sr\\S'Sr \\S'Sr g)"AttentionTextGenerationModelOutputica_The 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. NrrrrrJrrrrUrUcs'J M6 "OV"rrUc\rSrSr%SrSr\\S'Sr\ \ \\S'Sr \ \ \ \\S'Sr \ \ \ \\S'Sr g) TokenGeneratorOutputiraG 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+rrr)rrrrrrXrrr+rrrrrrrrrWrWrsV0Iv&*FHU6] #*15JuV}-.548M8E%-018rrWc`\rSrSr%SrSr\\S'Sr\\S'Sr \\S'Sr \\S'Sr \\S'S r g) TokenClassificationModelOutputia The 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_mappingrM label_maskr) rrrrrr.rrr-r[rMr\rrrrrZrZs; FFD&!NF!KJrrZc6\rSrSr%SrSr\\S'Sr\\S'Sr g)'AttentionTokenClassificationModelOutputizThe 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. Nrrr) rrrrrrrrrrrrrr^r^s J M6 rr^c(\rSrSr%SrSr\\S'Srg)-DialogueUserSatisfactionEstimationModelOutputizqThe output class for user satisfaction estimation. Args: logits (`Tensor`): The logits output of the model. Nr.r) rrrrrr.rrrrrrr`r`s FFrr`cD\rSrSr%SrSr\\S'Sr\\S'Sr \\S'Sr g)SentencEmbeddingModelOutputia(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. Nquery_embeddingsdoc_embeddingsr-r) rrrrrrcrrrdr-rrrrrbrbs( $f#!NF!D&rrbcJ\rSrSr%SrSr\\S'Sr\\S'Sr \ \ \S'Sr g)TranslationEvaluationOutputiz8The output class for translation evaluation models. Nscorer- input_formatr) rrrrrrgrrr-rhrstrrrrrrfrfs+E6D&"L$s)"rrfc\rSrSr%SrSr\\\S'Sr \\\S'Sr \\S'Sr \\ \\S'Sr \\ \\S'Sr\\S 'S rg) !MachineReadingComprehensionOutputiaThe 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_logitsrrr6r)rrrrrr-rrrrlrmrrrr6rrrrrkrksa "D(6 !#'J 'K-1M8E&M*1*.Jv'.Ivrrk)" dataclassesrtypingrrrrnumpyr?modelscope.outputs.outputsrrr rr!r)r0r4r8r;rBrErIrLrQrSrUrWrZr^r`rbrfrkrrrrrs!//6 * +  !/ !  !  &$#6&$ &$R P7P7 P7f   "o" " !/! !" #6   /    P7oP7 P7f  O     #-J #  #   /        #)B #  # 9?9 9> _ & !.L! ! O   /    #/# #  r