models
详细介绍了Transformers.js中所有可用的模型。
示例: 加载并运行一个AutoModel
。
import { AutoModel, AutoTokenizer } from '@xenova/transformers';
let tokenizer = await AutoTokenizer.from_pretrained('Xenova/bert-base-uncased');
let model = await AutoModel.from_pretrained('Xenova/bert-base-uncased');
let inputs = await tokenizer('I love transformers!');
let { logits } = await model(inputs);
// Tensor {
// data: Float32Array(183132) [-7.117443084716797, -7.107812881469727, -7.092104911804199, ...]
// dims: (3) [1, 6, 30522],
// type: "float32",
// size: 183132,
// }
我们还提供了其他AutoModel
(如下所示),您可以使用与Python库相同的方式使用它们。例如
示例: 加载并运行一个AutoModelForSeq2SeqLM
。
import { AutoModelForSeq2SeqLM, AutoTokenizer } from '@xenova/transformers';
let tokenizer = await AutoTokenizer.from_pretrained('Xenova/t5-small');
let model = await AutoModelForSeq2SeqLM.from_pretrained('Xenova/t5-small');
let { input_ids } = await tokenizer('translate English to German: I love transformers!');
let outputs = await model.generate(input_ids);
let decoded = tokenizer.decode(outputs[0], { skip_special_tokens: true });
// 'Ich liebe Transformatoren!'
- 模型
- 静态
- .PreTrainedModel
new PreTrainedModel(config, session)
- 实例
.dispose()
⇒Promise.<Array<unknown>>
._call(model_inputs)
⇒Promise.<Object>
.forward(model_inputs)
⇒Promise.<Object>
._get_generation_config(generation_config)
⇒*
.groupBeams(beams)
⇒Array
.getPastKeyValues(decoderResults, pastKeyValues)
⇒Object
.getAttentions(decoderResults)
⇒Object
.addPastKeyValues(decoderFeeds, pastKeyValues)
- 静态
.from_pretrained(pretrained_model_name_or_path, options)
⇒Promise.<PreTrainedModel>
- .BaseModelOutput
- .BertForMaskedLM
._call(model_inputs)
⇒Promise.<MaskedLMOutput>
- .BertForSequenceClassification
._call(model_inputs)
⇒Promise.<SequenceClassifierOutput>
- .BertForTokenClassification
._call(model_inputs)
⇒Promise.<TokenClassifierOutput>
- .BertForQuestionAnswering
._call(model_inputs)
返回Promise.<QuestionAnsweringModelOutput>
- RoFormerModel
- RoFormerForMaskedLM
._call(model_inputs)
返回Promise.<MaskedLMOutput>
- RoFormerForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- RoFormerForTokenClassification
._call(model_inputs)
返回Promise.<TokenClassifierOutput>
- RoFormerForQuestionAnswering
._call(model_inputs)
返回Promise.<QuestionAnsweringModelOutput>
- ConvBertModel
- ConvBertForMaskedLM
._call(model_inputs)
返回Promise.<MaskedLMOutput>
- ConvBertForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- ConvBertForTokenClassification
._call(model_inputs)
返回Promise.<TokenClassifierOutput>
- ConvBertForQuestionAnswering
._call(model_inputs)
返回Promise.<QuestionAnsweringModelOutput>
- ElectraModel
- ElectraForMaskedLM
._call(model_inputs)
返回Promise.<MaskedLMOutput>
- ElectraForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- ElectraForTokenClassification
._call(model_inputs)
返回Promise.<TokenClassifierOutput>
- ElectraForQuestionAnswering
._call(model_inputs)
返回Promise.<QuestionAnsweringModelOutput>
- CamembertModel
- CamembertForMaskedLM
._call(model_inputs)
返回Promise.<MaskedLMOutput>
- CamembertForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- CamembertForTokenClassification
._call(model_inputs)
返回Promise.<TokenClassifierOutput>
- CamembertForQuestionAnswering
._call(model_inputs)
返回Promise.<QuestionAnsweringModelOutput>
- DebertaModel
- DebertaForMaskedLM
._call(model_inputs)
返回Promise.<MaskedLMOutput>
- DebertaForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- DebertaForTokenClassification
._call(model_inputs)
返回Promise.<TokenClassifierOutput>
- DebertaForQuestionAnswering
._call(model_inputs)
返回Promise.<QuestionAnsweringModelOutput>
- DebertaV2Model
- DebertaV2ForMaskedLM
._call(model_inputs)
返回Promise.<MaskedLMOutput>
- DebertaV2ForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- DebertaV2ForTokenClassification
._call(model_inputs)
返回Promise.<TokenClassifierOutput>
- DebertaV2ForQuestionAnswering
._call(model_inputs)
返回Promise.<QuestionAnsweringModelOutput>
- DistilBertForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- DistilBertForTokenClassification
._call(model_inputs)
返回Promise.<TokenClassifierOutput>
- DistilBertForQuestionAnswering
._call(model_inputs)
返回Promise.<QuestionAnsweringModelOutput>
- DistilBertForMaskedLM
._call(model_inputs)
返回Promise.<MaskedLMOutput>
- EsmModel
- EsmForMaskedLM
._call(model_inputs)
返回Promise.<MaskedLMOutput>
- EsmForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- EsmForTokenClassification
._call(model_inputs)
返回Promise.<TokenClassifierOutput>
- .MobileBertForMaskedLM
._call(model_inputs)
返回Promise.<MaskedLMOutput>
- .MobileBertForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- .MobileBertForQuestionAnswering
._call(model_inputs)
返回Promise.<QuestionAnsweringModelOutput>
- .MPNetModel
- .MPNetForMaskedLM
._call(model_inputs)
返回Promise.<MaskedLMOutput>
- .MPNetForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- .MPNetForTokenClassification
._call(model_inputs)
返回Promise.<TokenClassifierOutput>
- .MPNetForQuestionAnswering
._call(model_inputs)
返回Promise.<QuestionAnsweringModelOutput>
- .T5ForConditionalGeneration
- .LongT5PreTrainedModel
- .LongT5Model
- .LongT5ForConditionalGeneration
- .MT5ForConditionalGeneration
- .BartModel
- .BartForConditionalGeneration
- .BartForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- .MBartModel
- .MBartForConditionalGeneration
- .MBartForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- .MBartForCausalLM
- .BlenderbotModel
- .BlenderbotForConditionalGeneration
- .BlenderbotSmallModel
- .BlenderbotSmallForConditionalGeneration
- .RobertaForMaskedLM
._call(model_inputs)
返回Promise.<MaskedLMOutput>
- .RobertaForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- .RobertaForTokenClassification
._call(model_inputs)
返回Promise.<TokenClassifierOutput>
- .RobertaForQuestionAnswering
._call(model_inputs)
返回Promise.<QuestionAnsweringModelOutput>
- .XLMPreTrainedModel
- .XLMModel
- .XLMWithLMHeadModel
._call(model_inputs)
返回Promise.<MaskedLMOutput>
- .XLMForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- .XLMForTokenClassification
._call(model_inputs)
返回Promise.<TokenClassifierOutput>
- .XLMForQuestionAnswering
._call(model_inputs)
返回Promise.<QuestionAnsweringModelOutput>
- .XLMRobertaForMaskedLM
._call(model_inputs)
返回Promise.<MaskedLMOutput>
- .XLMRobertaForSequenceClassification
._call(model_inputs)
返回Promise.<SequenceClassifierOutput>
- .XLMRobertaForTokenClassification
._call(model_inputs)
返回Promise.<TokenClassifierOutput>
- .XLMRobertaForQuestionAnswering
._call(model_inputs)
返回Promise.<QuestionAnsweringModelOutput>
- .ASTModel
- .ASTForAudioClassification
- .WhisperModel
- .WhisperForConditionalGeneration
- .视觉编码器-解码器模型
- .CLIP模型
- .CLIP文本模型
.from_pretrained()
:预训练模型.from_pretrained
- .CLIP文本模型带投影
.from_pretrained()
:预训练模型.from_pretrained
- .CLIP视觉模型
.from_pretrained()
:预训练模型.from_pretrained
- .CLIP视觉模型带投影
.from_pretrained()
:预训练模型.from_pretrained
- .Siglip模型
- .Siglip文本模型
.from_pretrained()
:预训练模型.from_pretrained
- .Siglip视觉模型
.from_pretrained()
:预训练模型.from_pretrained
- .CLIP图像分割模型
- .GPT2预训练模型
- .GPT2语言模型头部模型
- .GPTNeo预训练模型
- .GPTNeoX预训练模型
- .GPTJ预训练模型
- .GPTBigCode预训练模型
- .代码生成预训练模型
- .代码生成模型
- .代码生成因果语言模型
- .Llama预训练模型
- .Llama模型
- .Qwen2预训练模型
- .Qwen2模型
- .Phi预训练模型
- .Phi模型
- .Bloom预训练模型
- .Bloom模型
- .Bloom因果语言模型
- .Mpt预训练模型
- .Mpt模型
- .Mpt因果语言模型
- .OPT预训练模型
- .OPT模型
- .OPT因果语言模型
- .VitMatte图像抠图模型
- .Detr对象检测输出
- .Detr分割输出
- .表格转换模型
- .表格转换对象检测模型
- .ResNet预训练模型
- .ResNet模型
- .ResNet图像分类模型
- .Swin2SR模型
- .Swin2SR图像超分辨率模型
- .DPT模型
- .DPT深度估计模型
- .DepthAnything深度估计模型
- .GLPN模型
- .GLPN深度估计模型
- ._donutSwin模型
- .ConvNext模型
- .ConvNext图像分类模型
- .ConvNextV2模型
- .ConvNextV2图像分类模型
- .Dinov2模型
- .Dinov2图像分类模型
- .Yolos对象检测输出
- .Sam模型
new Sam模型(config, 视觉编码器, 提示编码器掩码解码器)
.get_image_embeddings(model_inputs)
⇒Promise.<{image_embeddings: Tensor, image_positional_embeddings: Tensor}>
.forward(model_inputs)
⇒Promise.<Object>
._call(model_inputs)
⇒Promise.<SamImageSegmentationOutput>
- .Sam图像分割输出
- .MarianMT模型
- .M2M100条件生成模型
- .Wav2Vec2模型
- .Wav2Vec2音频帧分类模型
._call(model_inputs)
⇒Promise.<TokenClassifierOutput>
- .UniSpeech模型
- .UniSpeech序列到序列分类模型
- .UniSpeech序列分类模型
._call(model_inputs)
⇒Promise.<SequenceClassifierOutput>
- .UniSpeechSat模型
- .UniSpeechSat序列到序列分类模型
- .UniSpeechSat序列分类模型
._call(model_inputs)
⇒Promise.<SequenceClassifierOutput>
- .UniSpeechSat音频帧分类模型
._call(model_inputs)
⇒Promise.
- .Wav2Vec2BertModel
- .Wav2Vec2BertForCTC
- .Wav2Vec2BertForSequenceClassification
._call(model_inputs)
⇒Promise.
- .HubertModel
- .HubertForCTC
- .HubertForSequenceClassification
._call(model_inputs)
⇒Promise.
- .WavLMPreTrainedModel
- .WavLMModel
- .WavLMForCTC
- .WavLMForSequenceClassification
._call(model_inputs)
⇒Promise.
- .WavLMForXVector
._call(model_inputs)
⇒Promise.
- .WavLMForAudioFrameClassification
._call(model_inputs)
⇒Promise.
- .SpeechT5PreTrainedModel
- .SpeechT5Model
- .SpeechT5ForSpeechToText
- .SpeechT5ForTextToSpeech
- .SpeechT5HifiGan
- .TrOCRPreTrainedModel
- .TrOCRForCausalLM
- .MistralPreTrainedModel
- .Starcoder2PreTrainedModel
- .FalconPreTrainedModel
- .ClapTextModelWithProjection
.from_pretrained()
:PreTrainedModel.from_pretrained
- .ClapAudioModelWithProjection
.from_pretrained()
:PreTrainedModel.from_pretrained
- .VitsModel
._call(model_inputs)
⇒Promise.
- .SegformerModel
- .SegformerForImageClassification
- .SegformerForSemanticSegmentation
- .StableLmPreTrainedModel
- .StableLmModel
- .StableLmForCausalLM
- .EfficientNetModel
- .EfficientNetForImageClassification
- .DecisionTransformerModel
- .PretrainedMixin
- 实例
- 静态
.from_pretrained()
:PreTrainedModel.from_pretrained
- .AutoModel
- .AutoModelForSequenceClassification
- .AutoModelForTokenClassification
- .AutoModelForSeq2SeqLM
- .AutoModelForSpeechSeq2Seq
- .AutoModelForTextToSpectrogram
- .AutoModelForTextToWaveform
- .AutoModelForCausalLM
- .AutoModelForMaskedLM
- .AutoModelForQuestionAnswering
- .AutoModelForVision2Seq
- .AutoModelForImageClassification
- .AutoModelForImageSegmentation
- .AutoModelForSemanticSegmentation
- .AutoModelForObjectDetection
- .AutoModelForMaskGeneration
- .Seq2SeqLMOutput
- .SequenceClassifierOutput
- .XVectorOutput
- .TokenClassifierOutput
- .MaskedLMOutput
- .QuestionAnsweringModelOutput
- .CausalLMOutput
- .CausalLMOutputWithPast
- .ImageMattingOutput
- .VitsModelOutput
- .PreTrainedModel
- 内部
~InferenceSession
:*
~TypedArray
:*
~DecoderOutput
⇒Promise.<(Array.
>|EncoderDecoderOutput|DecoderOutput)> ~WhisperGenerationConfig
:Object
~SamModelInputs
:Object
~SpeechOutput
:Object
- 静态
models.PreTrainedModel
为预训练模型提供模型配置和ONNX会话的基类。
类型: models
的静态类
- .PreTrainedModel
new PreTrainedModel(config, session)
- 实例
.dispose()
⇒Promise.<Array<unknown>>
._call(model_inputs)
⇒Promise.<Object>
.forward(model_inputs)
⇒Promise.<Object>
._get_generation_config(generation_config)
⇒*
.groupBeams(beams)
⇒Array
.getPastKeyValues(decoderResults, pastKeyValues)
⇒Object
.getAttentions(decoderResults)
⇒Object
.addPastKeyValues(decoderFeeds, pastKeyValues)
- 静态
.from_pretrained(pretrained_model_name_or_path, options)
⇒Promise.<PreTrainedModel>
new PreTrainedModel(config, session)
创建 PreTrainedModel
类的新实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型配置。 |
session | 任意类型 | 模型的会话。 |
preTrainedModel.dispose() ⇒ <code> Promise. < Array < unknown > > </code>
释放推理过程中创建的所有ONNX会话。
类型: PreTrainedModel
的实例方法
返回值: Promise.<Array<unknown>>
- 每个将要释放的ONNX会话的promise数组。
待办
preTrainedModel._call(model_inputs) ⇒ <code> Promise. < Object > </code>
使用提供的输入运行模型
类型: PreTrainedModel
的实例方法
返回值: Promise.
- 包含输出张量的对象
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 包含输入张量的对象 |
preTrainedModel.forward(model_inputs) ⇒ <code> Promise. < Object > </code>
预训练模型的正向方法。如果没有被子类覆盖,将根据模型类型选择正确的正向方法。
类型: PreTrainedModel
的实例方法
返回值: Promise.
- 模型以ONNX模型中指定的格式返回的输出数据。
抛出异常:
Error
此方法必须在子类中实现。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | ONNX模型中指定的格式模型输入数据。 |
preTrainedModel._get_generation_config(generation_config) ⇒ <code> * </code>
此函数将多个生成配置合并在一起以形成最终生成配置,该配置将被模型用于文本生成。它首先创建一个空的GenerationConfig
对象,然后将其应用于模型自己的generation_config
属性。最后,如果传递了generation_config
对象,它将使用传递的配置对象的相应属性覆盖最终配置中的相应属性。
类型: PreTrainedModel
的实例方法
返回值: *
- 模型用于文本生成的最终生成配置对象。
参数 | 类型 | 说明 |
---|---|---|
generation_config | * | 包含生成参数的 |
preTrainedModel.groupBeams(beams) ⇒ <code>Array</code>
按ID分组一串beam对象。
类型: PreTrainedModel
的实例方法
返回值: Array
- 一个二维数组,内部数组包含具有相同ID的beam对象。
参数 | 类型 | 说明 |
---|---|---|
beams | Array | 要分组的beam对象数组。 |
preTrainedModel.getPastKeyValues(decoderResults, pastKeyValues) ⇒ <code>Object</code>
从给定的解码结果对象中返回包含过去关键值的对象。
类型: PreTrainedModel
的实例方法
返回值: Object
- 包含过去关键值的对象。
参数 | 类型 | 说明 |
---|---|---|
decoderResults | 对象 | 解码结果对象。 |
pastKeyValues | 对象 | 之前的过去关键值。 |
preTrainedModel.getAttentions(decoderResults) ⇒ <code>Object</code>
从给定的解码结果对象中返回包含注意力的对象。
类型: PreTrainedModel
的实例方法
返回值: Object
- 包含注意力的对象。
参数 | 类型 | 说明 |
---|---|---|
decoderResults | 对象 | 解码结果对象。 |
预训练Model.addPastKeyValues(decoderFeeds, pastKeyValues)
将过去键值添加到解码器输入对象中。如果pastKeyValues为null,则创建新的过去键值张量。
类型: PreTrainedModel
的实例方法
参数 | 类型 | 说明 |
---|---|---|
decoderFeeds | 对象 | 要添加过去键值的目标解码器输入对象。 |
pastKeyValues | 对象 | 包含过去键值的对象。 |
PreTrainedModel.from_pretrained(pretrained_model_name_or_path, options) ⇒ <code> Promise. < PreTrainedModel > </code>
从预训练模型实例化库中的某个模型类。
根据配置对象(可以作为一个参数传递,或者在可能的情况下从pretrained_model_name_or_path加载)的model_type
属性选择要实例化的模型类。
类型:PreTrainedModel
的静态方法
返回值:Promise.<PreTrainedModel>
- PreTrainedModel
类的新实例。
参数 | 类型 | 说明 |
---|---|---|
pretrained_model_name_or_path | 字符串 | 预训练模型的名称或路径。可以是以下任一项:
|
options | * | 加载模型的附加选项。 |
models.BaseModelOutput
模型输出的基本类,包含潜在的隐藏状态和注意力。
类型: models
的静态类
new BaseModelOutput(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.last_hidden_state | 张量(Tensor) | 模型最后一层输出处的隐藏状态序列。 |
[output.hidden_states] | 张量(Tensor) | 模型每层输出处的隐藏状态以及可选的初始嵌入输出。 |
[output(attentions)] | 张量(Tensor) | 注意力权重在注意力softmax之后,用于计算自注意力头中的加权的平均。 |
models.BertForMaskedLM
BertForMaskedLM 是一个代表 BERT 模型用于掩码语言模型的类。
类型: models
的静态类
bertForMaskedLM._call(model_inputs) ⇒ <code> Promise<MaskedLMOutput></code>
在新的输入上调用模型。
类型: BertForMaskedLM
的实例方法
返回值: Promise<MaskedLMOutput>
- 包含模型在掩码语言模型中输出 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.BertForSequenceClassification
BertForSequenceClassification 是代表序列分类 BERT 模型的一个类。
类型: models
的静态类
bertForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型:类 BertForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.BertForTokenClassification
BertForTokenClassification 是代表标记分类 BERT 模型的一个类。
类型: models
的静态类
bertForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型:类 BertForTokenClassification
的实例方法
返回: Promise.<TokenClassifierOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.BertForQuestionAnswering
BertForQuestionAnswering 类用于表示用于问答任务的 BERT 模型。
类型: models
的静态类
bertForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>
在新的输入上调用模型。
类型: BertForQuestionAnswering
的实例方法
返回: Promise.<QuestionAnsweringModelOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.RoFormerModel
RoFormer 模型,输出原始隐藏状态而没有顶部的特定头。
类型: models
的静态类
models.RoFormerForMaskedLM
RoFormer模型顶部带有语言模型
头。
类型: models
的静态类
roFormerForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>
在新的输入上调用模型。
类型:类RoFormerForMaskedLM
的实例方法
返回值: Promise<MaskedLMOutput>
- 包含模型在掩码语言模型中输出 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.RoFormerForSequenceClassification
RoFormer模型具有顶部带顺序分类/回归头的transformer模型(在池化输出之上的线性层)
类型: models
的静态类
roFormerForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型:类RoFormerForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.RoFormerForTokenClassification
在RoFormer模型顶部添加一个token分类头(隐藏状态输出上的线性层),例如用于命名实体识别(NER)任务。
类型: models
的静态类
roFormerForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型:RoFormerForTokenClassification
类的实例方法
返回: Promise.<TokenClassifierOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.RoFormerForQuestionAnswering
RoFormer模型顶部添加span分类头,用于SQuAD等抽取式问答任务(在隐藏状态输出上方添加线性层来计算“span start logits”和“span end logits”)。
类型: models
的静态类
roFormerForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>
在新的输入上调用模型。
类型:`RoFormerForQuestionAnswering
` 的实例方法
返回: Promise.<QuestionAnsweringModelOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.ConvBertModel
一个不带任何特定头部、直接输出原始隐藏状态的ConvBERT模型。
类型: models
的静态类
models.ConvBertForMaskedLM
在顶部添加了语言建模头部的ConvBERT模型。
类型: models
的静态类
convBertForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>
在新的输入上调用模型。
类型:`ConvBertForMaskedLM
` 的实例方法
返回值: Promise<MaskedLMOutput>
- 包含模型在掩码语言模型中输出 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.ConvBertForSequenceClassification
ConvBERT模型,顶部带有序列分类/回归头(池化输出的线性层)。
类型: models
的静态类
convBertForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型:ConvBertForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models(ConvBertForTokenClassification)
ConvBERT模型,顶部带有标记分类头(隐藏状态输出的线性层),例如用于命名实体识别(NER)任务。
类型: models
的静态类
convBertForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型:类方法 ConvBertForTokenClassification
返回: Promise.<TokenClassifierOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.ConvBertForQuestionAnswering
在ConvBERT模型顶部增加跨分类头,适用于SQuAD等抽取式问答任务(在hidden-states输出之上增加线性层以计算span start logits
和span end logits
)
类型: models
的静态类
convBertForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>
在新的输入上调用模型。
类型:类方法 ConvBertForQuestionAnswering
返回: Promise.<QuestionAnsweringModelOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.ElectraModel
裸Electra模型,输出原始hidden-states,在顶部没有特定的头。除了使用一个额外的线性层在嵌入层和编码器之间(如果隐藏大小和嵌入大小不同)外,与BERT模型相同。
类型: models
的静态类
models.ElectraForMaskedLM
带语言建模头的Electra模型。
类型: models
的静态类
electraForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>
在新的输入上调用模型。
类型:ElectraForMaskedLM
的实例方法
返回值: Promise<MaskedLMOutput>
- 包含模型在掩码语言模型中输出 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.ElectraForSequenceClassification
带序列分类/回归头的ELECTRA模型转换器(在池化输出之上加一个线性层)
类型: models
的静态类
electraForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型:ElectraForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.ElectraForTokenClassification
带有关键词分类头的 ELECTRA 模型。
类型: models
的静态类
electraForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型: ElectraForTokenClassification
的实例方法
返回: Promise.<TokenClassifierOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.ElectraForQuestionAnswering
带有关键词分类头的 ELECTRA 模型,用于提取式问答任务,如SQuAD(在隐藏状态输出之上使用线性层来计算 span起始logits
和 span结束logits
)。
类型: models
的静态类
electraForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>
在新的输入上调用模型。
类型: ElectraForQuestionAnswering
的实例方法
返回: Promise.<QuestionAnsweringModelOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.CamembertModel
仅包含 CamemBERT 模型变压器,无任何特定头部用于输出原始隐藏状态的版本。
类型: models
的静态类
models.CamembertForMaskedLM
CamemBERT 模型,顶部带有 语言模型
头部。
类型: models
的静态类
camembertForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>
在新的输入上调用模型。
类型: CamembertForMaskedLM
的实例方法。
返回值: Promise<MaskedLMOutput>
- 包含模型在掩码语言模型中输出 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.CamembertForSequenceClassification
CamemBERT 模型变换器,顶部带有序列分类/回归头部(池化输出之上的线性层),例如用于 GLUE 任务。
类型: models
的静态类
camembertForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型:类 CamembertForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.CamembertForTokenClassification
顶部的标记分类头(在隐藏状态输出之上的一层线性层)的 CamemBERT 模型,例如用于命名实体识别(NER)任务。
类型: models
的静态类
camembertForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型:类 CamembertForTokenClassification
的实例方法
返回: Promise.<TokenClassifierOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.CamembertForQuestionAnswering
CamemBERT 模型,在顶部添加了用于提取式问答任务的 span 分类头
类型: models
的静态类
camembertForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>
在新的输入上调用模型。
类型: CamembertForQuestionAnswering
的实例方法
返回: Promise.<QuestionAnsweringModelOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.DebertaModel
裸 DeBERTa 模型变换器,输出的是原始隐藏状态,没有添加任何特定头
类型: models
的静态类
models.DebertaForMaskedLM
DeBERTa 模型,顶部添加了 语言模型
头
类型: models
的静态类
debertaForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>
在新的输入上调用模型。
类型: DebertaForMaskedLM
的实例方法
返回值: Promise<MaskedLMOutput>
- 包含模型在掩码语言模型中输出 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.DebertaForSequenceClassification
DeBERTa 模型,在序列分类/回归头部(对池化输出之上的线性层)之上
类型: models
的静态类
debertaForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型: DebertaForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.DebertaForTokenClassification
DeBERTa 模型,在标记分类头部(在隐藏状态输出之上的线性层)之上,例如用于命名实体识别(NER)任务。
类型: models
的静态类
debertaForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型: DebertaForTokenClassification
的实例方法
返回: Promise.<TokenClassifierOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.DebertaForQuestionAnswering
在SQuAD(一种用于问答任务的DeBERTa模型,在隐藏态输出之上建立线性层以计算span start logits
和span end logits
)的顶部带有跨度分类头。
类型: models
的静态类
debertaForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>
在新的输入上调用模型。
类型: DebertaForQuestionAnswering
的实例方法
返回: Promise.<QuestionAnsweringModelOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.DebertaV2Model
DeBERTa-V2 模型,输出原始隐藏状态,无顶部的特定头。
类型: models
的静态类
models.DebertaV2ForMaskedLM
DeBERTa-V2 模型,顶部带有 语言模型
头。
类型: models
的静态类
debertaV2ForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>
在新的输入上调用模型。
类型: DebertaV2ForMaskedLM
的实例方法
返回值: Promise<MaskedLMOutput>
- 包含模型在掩码语言模型中输出 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.DebertaV2ForSequenceClassification
DeBERTa-V2 模型与顶部的序列分类/回归头(位于池化输出之上的线性层)。
类型: models
的静态类
debertaV2ForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型: DebertaV2ForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.DebertaV2ForTokenClassification
在DeBERTa-V2模型顶部添加一个标记分类头(在隐藏状态输出之上的线性层),例如用于命名实体识别(NER)任务。
类型: models
的静态类
debertaV2ForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型: DebertaV2ForTokenClassification
的实例方法
返回: Promise.<TokenClassifierOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.DebertaV2ForQuestionAnswering
DeBERTa-V2 模型,具有顶部用于提取式问答任务(如 SQuAD)的跨度分类头(在隐藏状态输出上添加线性层以计算 跨度起始得分
和 跨度结束得分
)。
类型: models
的静态类
debertaV2ForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>
在新的输入上调用模型。
类型:DebertaV2ForQuestionAnswering
的实例方法
返回: Promise.<QuestionAnsweringModelOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.DistilBertForSequenceClassification
DistilBertForSequenceClassification 是表示用于序列分类的 DistilBERT 模型的类。
类型: models
的静态类
distilBertForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型:DistilBertForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.DistilBertForTokenClassification
DistilBertForTokenClassification是一个表示适用于标记分类的DistilBERT模型的类。
类型: models
的静态类
distilBertForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型:是DistilBertForTokenClassification
的实例方法。
返回: Promise.<TokenClassifierOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.DistilBertForQuestionAnswering
DistilBertForQuestionAnswering是一个表示适用于问答的DistilBERT模型的类。
类型: models
的静态类
distilBertForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>
在新的输入上调用模型。
类型:是DistilBertForQuestionAnswering
的实例方法。
返回: Promise.<QuestionAnsweringModelOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.DistilBertForMaskedLM
DistilBertForMaskedLM 表示用于遮蔽任务的 DistilBERT 模型的类。
类型: models
的静态类
distilBertForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>
在新的输入上调用模型。
类型: DistilBertForMaskedLM
的实例方法
返回值: Promise.<MaskedLMOutput>
- 返回对象
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.EsmModel
裸 ESM 模型变压器,输出原始隐藏状态,不添加任何特定头部。
类型: models
的静态类
models.EsmForMaskedLM
在顶部具有 语言模型
头部的 ESM 模型。
类型: models
的静态类
esmForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>
在新的输入上调用模型。
类型: EsmForMaskedLM
的实例方法
返回值: Promise<MaskedLMOutput>
- 包含模型在掩码语言模型中输出 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.EsmForSequenceClassification
在序列分类/回归头部之上的 ESM 模型 transformer(在池化输出之上有一个线性层)
类型: models
的静态类
esmForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型: EsmForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.EsmForTokenClassification
顶部带有标记分类头部的 ESM 模型(在隐藏状态输出之上加一个线性层),例如用于命名实体识别 (NER) 任务。
类型: models
的静态类
esmForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型: EsmForTokenClassification
的实例方法
返回: Promise.<TokenClassifierOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.MobileBertForMaskedLM
MobileBertForMaskedLM 类代表用于遮蔽任务的 MobileBERT 模型。
类型: models
的静态类
mobileBertForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>
在新的输入上调用模型。
类型: <code>MobileBertForMaskedLM</code> 的实例方法
返回值: Promise.<MaskedLMOutput>
- 返回对象
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.MobileBertForSequenceClassification
MobileBert 模型,顶部有顺序分类/回归头(在池化输出之上的一层线性层)
类型: models
的静态类
mobileBertForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型: <code>MobileBertForSequenceClassification</code> 的实例方法
返回值: Promise.<SequenceClassifierOutput>
- 返回对象
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.MobileBertForQuestionAnswering
MobileBert 模型,顶部有跨度分类头,用于抽取式问答任务
类型: models
的静态类
mobileBertForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>
在新的输入上调用模型。
类型:类 MobileBertForQuestionAnswering
的实例方法
返回值:返回对象 Promise.<QuestionAnsweringModelOutput>
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.MPNetModel
纯MPNet模型,输出原始隐藏状态,顶部不带任何特定头。
类型: models
的静态类
models.MPNetForMaskedLM
MPNetForMaskedLM 是表示 MPNet 遮蔽语言模型的一个类。
类型: models
的静态类
mpNetForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>
在新的输入上调用模型。
类型:类 MPNetForMaskedLM
的实例方法
返回值: Promise<MaskedLMOutput>
- 包含模型在掩码语言模型中输出 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.MPNetForSequenceClassification
MPNetForSequenceClassification 是表示用于序列分类的 MPNet 模型的类。
类型: models
的静态类
mpNetForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型: MPNetForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.MPNetForTokenClassification
MPNetForTokenClassification 是表示用于标记分类的 MPNet 模型的类。
类型: models
的静态类
mpNetForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型: MPNetForTokenClassification
的实例方法
返回: Promise.<TokenClassifierOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.MPNetForQuestionAnswering
MPNetForQuestionAnswering 是一个表示问答 MPNet 模型的类。
类型: models
的静态类
mpNetForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>
在新的输入上调用模型。
类型: MPNetForQuestionAnswering
类的实例方法
返回: Promise.<QuestionAnsweringModelOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.T5ForConditionalGeneration
T5Model 是一个表示条件生成 T5 模型的类。
类型: models
的静态类
new T5ForConditionalGeneration(config, session, decoder_merged_session, generation_config)
创建一个新的 T5ForConditionalGeneration
类实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型配置。 |
session | 任意类型 | 模型的会话。 |
decoder_merged_session | 任意类型 | 解码器的session。 |
generation_config | GenerationConfig | 生成配置。 |
一个抽象类,用于处理权重初始化以及下载和加载预训练模型的简单接口。
类型: models
的静态类
一个LONGT5模型,输出原始的隐藏状态,而没有在顶部添加任何特定的头。
类型: models
的静态类
在顶部长T5模型上添加了语言建模
头。
类型: models
的静态类
创建新的LongT5ForConditionalGeneration类的实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型配置。 |
session | 任意类型 | 模型的会话。 |
decoder_merged_session | 任意类型 | 解码器的session。 |
generation_config | GenerationConfig | 生成配置。 |
models.MT5ForConditionalGeneration
代表基于MT5架构的残留序列到序列模型的类。
类型: models
的静态类
new MT5ForConditionalGeneration(config, session, decoder_merged_session, generation_config)
创建了MT5ForConditionalGeneration
类的新实例。
参数 | 类型 | 说明 |
---|---|---|
config | 任意类型 | 模型配置。 |
session | 任意类型 | 包含编码器权重的ONNX会话。 |
decoder_merged_session | 任意类型 | 包含合并解码器权重的ONNX会话。 |
generation_config | GenerationConfig | 生成配置。 |
models.BartModel
裸BART模型,输出原始隐藏状态,没有顶部的特定头部。
类型: models
的静态类
models.BartForConditionalGeneration
具有语言建模头部的BART模型。可用于摘要。
类型: models
的静态类
new BartForConditionalGeneration(config, session, decoder_merged_session, generation_config)
创建一个新的 BartForConditionalGeneration
类的实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | Bart 模型的配置对象。 |
session | 对象 | 用于执行模型的 ONNX 会话。 |
decoder_merged_session | 对象 | 用于执行解码器的 ONNX 会话。 |
generation_config | 对象 | 生成配置对象。 |
models.BartForSequenceClassification
在序列分类的头(池化输出上的线性层)上添加了序列分类的 Bart 模型。
类型: models
的静态类
bartForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型: BartForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.MBartModel
裸MBART模型输出原始的隐藏状态,顶部没有特定的头。
类型: models
的静态类
models.MBartForConditionalGeneration
带有语言模型的MBART模型。在微调预训练模型后,可以用于摘要。
类型: models
的静态类
new MBartForConditionalGeneration(config, session, decoder_merged_session, generation_config)
创建MBartForConditionalGeneration
类的新实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | Bart 模型的配置对象。 |
session | 对象 | 用于执行模型的 ONNX 会话。 |
decoder_merged_session | 对象 | 用于执行解码器的 ONNX 会话。 |
generation_config | 对象 | 生成配置对象。 |
models.MBartForSequenceClassification
MBart模型顶部带有序列分类头(汇聚输出上的线性层)。
类型: models
的静态类
mBartForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型: MBartForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.MBartForCausalLM
类型: models
的静态类
new MBartForCausalLM(config, decoder_merged_session, generation_config)
创建一个新的 MBartForCausalLM
类实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型的配置对象。 |
decoder_merged_session | 对象 | 解码器的 ONNX Session 对象。 |
generation_config | 对象 | 生成过程的配置对象。 |
models.BlenderbotModel
纯 Blenderbot 模型输出,不带任何特定头部上的原始隐藏状态。
类型: models
的静态类
models.BlenderbotForConditionalGeneration
具有语言建模头的Blenderbot模型。可用于摘要。
类型: models
的静态类
new BlenderbotForConditionalGeneration(config, session, decoder_merged_session, generation_config)
创建一个BlenderbotForConditionalGeneration
类的新的实例。
参数 | 类型 | 说明 |
---|---|---|
config | 任意类型 | 模型配置。 |
session | 任意类型 | 包含编码器权重的ONNX会话。 |
decoder_merged_session | 任意类型 | 包含合并解码器权重的ONNX会话。 |
generation_config | GenerationConfig | 生成配置。 |
models.BlenderbotSmallModel
BlenderbotSmall模型,输出原始隐藏状态,没有顶部任何特定头。
类型: models
的静态类
models.BlenderbotSmallForConditionalGeneration
具有语言建模头的BlenderbotSmall模型。可用于摘要。
类型: models
的静态类
new BlenderbotSmallForConditionalGeneration(config, session, decoder_merged_session, generation_config)
创建一个BlenderbotForConditionalGeneration
类的新的实例。
参数 | 类型 | 说明 |
---|---|---|
config | 任意类型 | 模型配置。 |
session | 任意类型 | 包含编码器权重的ONNX会话。 |
decoder_merged_session | 任意类型 | 包含合并解码器权重的ONNX会话。 |
generation_config | GenerationConfig | 生成配置。 |
models.RobertaForMaskedLM
RobertaForMaskedLM 类,用于在 Roberta 模型上进行掩码语言建模。
类型: models
的静态类
robertaForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>
在新的输入上调用模型。
类型: RobertaForMaskedLM
的实例方法
返回值: Promise.<MaskedLMOutput>
- 返回对象
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.RobertaForSequenceClassification
RobertaForSequenceClassification 类,用于在 Roberta 模型上进行序列分类。
类型: models
的静态类
robertaForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型:模型 RobertaForSequenceClassification
的实例方法
返回值: Promise.<SequenceClassifierOutput>
- 返回对象
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.RobertaForTokenClassification
RobertaForTokenClassification 类用于在 Roberta 模型上执行标记分类。
类型: models
的静态类
robertaForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型:模型 RobertaForTokenClassification
的实例方法
返回: Promise.<TokenClassifierOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.RobertaForQuestionAnswering
RobertaForQuestionAnswering 类用于在 Roberta 模型上执行问答。
类型: models
的静态类
robertaForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>
在新的输入上调用模型。
类型: RobertaForQuestionAnswering
实例方法
返回值:返回对象 Promise.<QuestionAnsweringModelOutput>
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.XLMPreTrainedModel
一个抽象类,用于处理权重初始化以及下载和加载预训练模型的简单接口。
类型: models
的静态类
models.XLMModel
裸XLM模型转换器,输出原始隐藏状态而不带任何特定头部。
类型: models
的静态类
models.XLMWithLMHeadModel
在顶部添加了语言建模头部(与输入嵌入相连的线性层)的XLM模型转换器。
类型: models
的静态类
xlmWithLMHeadModel._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>
在新的输入上调用模型。
类型: XLMWithLMHeadModel
的实例方法
返回值: Promise.<MaskedLMOutput>
- 返回对象
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.XLMForSequenceClassification
XLM 模型,顶部带有序列分类/回归头(在全局输出上使用线性层)
类型: models
的静态类
xlmForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型: XLMForSequenceClassification
的实例方法
返回值: Promise.<SequenceClassifierOutput>
- 返回对象
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.XLMForTokenClassification
XLM 模型,顶部带有标记分类头(在隐藏状态输出上使用线性层)
类型: models
的静态类
xlmForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型: XLMForTokenClassification
的实例方法
返回: Promise.<TokenClassifierOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.XLMForQuestionAnswering
在XLM模型顶部带有跨度分类头,用于提取式问答任务
类型: models
的静态类
xlmForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>
在新的输入上调用模型。
类型: XLMForQuestionAnswering
的实例方法
返回值:返回对象 Promise.<QuestionAnsweringModelOutput>
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.XLMRobertaForMaskedLM
实现XLMRoberta模型上掩码语言建模的XLMRobertaForMaskedLM类
类型: models
的静态类
xlmRobertaForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>
在新的输入上调用模型。
类型: XLMRobertaForMaskedLM
的实例方法
返回值: Promise.<MaskedLMOutput>
- 返回对象
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.XLMRobertaForSequenceClassification
XLMRobertaForSequenceClassification 类用于在 XLMRoberta 模型上执行序列分类。
类型: models
的静态类
xlmRobertaForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型: XLMRobertaForSequenceClassification
的实例方法
返回值: Promise.<SequenceClassifierOutput>
- 返回对象
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.XLMRobertaForTokenClassification
XLMRobertaForTokenClassification 类用于在 XLMRoberta 模型上执行标记分类。
类型: models
的静态类
PyXLMRobertaForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型:PyXLMRobertaForTokenClassification 的实例方法
返回: Promise.<TokenClassifierOutput>
- 包含模型输出标签分类 logits 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.XLMRobertaForQuestionAnswering
用于在 XLMRoberta 模型上执行问答任务的 XLMRobertaForQuestionAnswering 类。
类型: models
的静态类
PyXLMRobertaForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>
在新的输入上调用模型。
类型:PyXLMRobertaForQuestionAnswering 的实例方法
返回值:返回对象 Promise.<QuestionAnsweringModelOutput>
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.ASTModel
不带任何特定头部输出的纯 AST 模型转换器,输出原始隐藏状态。
类型: models
的静态类
models.ASTForAudioClassification
带音频分类头(池化输出的线性层)的音频频谱变换模型,例如用于AudioSet、Speech Commands v2等数据集。
类型: models
的静态类
models.WhisperModel
WhisperModel类,用于训练不带语言模型头的Whisper模型。
类型: models
的静态类
models.WhisperForConditionalGeneration
用于从Whisper模型生成条件输出的WhisperForConditionalGeneration类。
类型: models
的静态类
new WhisperForConditionalGeneration(config, session, decoder_merged_session, generation_config)
创建一个新的WhisperForConditionalGeneration
类的实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型的配置对象。 |
session | 对象 | ONNX会话对象用于模型。 |
decoder_merged_session | 对象 | 解码器的 ONNX Session 对象。 |
generation_config | 对象 | 生成过程的配置对象。 |
whisperForConditionalGeneration.generate inputs, 生成配置, logits_processor) ⇒ <code> Promise. < 对象 > </code>
基于输入和生成配置生成输出。
类型: WhisperForConditionalGeneration
的实例方法
返回值: Promise.<Object>
- Promise 对象代表生成的输出。
参数 | 类型 | 默认 | 说明 |
---|---|---|---|
inputs | 对象 | 模型输入数据。 | |
generation_config | WhisperGenerationConfig |
| 生成过程的配置对象。 |
logits_processor | 对象 |
| 可选的 logits 处理器对象。 |
whisperForConditionalGeneration._extract_token_timestamps(generate_outputs, alignment_heads, [num_frames], [time_precision]) ⇒ <code> Tensor </code>
通过编码器-解码器交叉注意力和动态时间扭曲(DTW)计算基于token级别的时序。
类型: WhisperForConditionalGeneration
的实例方法
返回值: Tensor
- 包含每个预测token的时序(秒)的张量。
参数 | 类型 | 默认 | 说明 |
---|---|---|---|
generate_outputs | 对象 | 模型生成的输出。 | |
generate_outputs.cross_attentions | Array.<Array<Array<Tensor>>> | 模型输出的交叉注意力。 | |
generate_outputs.decoder_attentions | Array.<Array<Array<Tensor>>> | 模型输出的解码注意力。 | |
generate_outputs.sequences | Array.<Array<number>> | 模型输出的序列。 | |
alignment_heads | Array.<Array<number>> | 模型的对齐头。 | |
[num_frames] | 数字 |
| 输入音频的帧数。 |
[time_precision] | 数字 | 0.02 | 时序的精度(秒)。 |
models.VisionEncoderDecoderModel
基于OpenAI的GPT架构,用于图像标题和其他视觉任务的全视觉编码器-解码器模型
类型: models
的静态类
new VisionEncoderDecoderModel(config, session, decoder_merged_session, generation_config)
创建一个VisionEncoderDecoderModel
类的新实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 指定超参数和其他模型设置的配置对象。 |
session | 对象 | 包含编码模型的ONNX会话。 |
decoder_merged_session | 任意类型 | 包含合并解码模型的ONNX会话。 |
generation_config | 对象 | 生成过程的配置对象。 |
models.CLIPModel
具有顶部投影层的CLIP文本和视觉模型
示例:使用CLIPModel
执行零样本图像分类。
import { AutoTokenizer, AutoProcessor, CLIPModel, RawImage } from '@xenova/transformers';
// Load tokenizer, processor, and model
let tokenizer = await AutoTokenizer.from_pretrained('Xenova/clip-vit-base-patch16');
let processor = await AutoProcessor.from_pretrained('Xenova/clip-vit-base-patch16');
let model = await CLIPModel.from_pretrained('Xenova/clip-vit-base-patch16');
// Run tokenization
let texts = ['a photo of a car', 'a photo of a football match']
let text_inputs = tokenizer(texts, { padding: true, truncation: true });
// Read image and run processor
let image = await RawImage.read('https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/football-match.jpg');
let image_inputs = await processor(image);
// Run model with both text and pixel inputs
let output = await model({ ...text_inputs, ...image_inputs });
// {
// logits_per_image: Tensor {
// dims: [ 1, 2 ],
// data: Float32Array(2) [ 18.579734802246094, 24.31830596923828 ],
// },
// logits_per_text: Tensor {
// dims: [ 2, 1 ],
// data: Float32Array(2) [ 18.579734802246094, 24.31830596923828 ],
// },
// text_embeds: Tensor {
// dims: [ 2, 512 ],
// data: Float32Array(1024) [ ... ],
// },
// image_embeds: Tensor {
// dims: [ 1, 512 ],
// data: Float32Array(512) [ ... ],
// }
// }
类型: models
的静态类
models.CLIPTextModel
不带任何头部或投影层的CLIP文本模型。
类型: models
的静态类
CLIPTextModel.from_pretrained() : <code> PreTrainedModel.from_pretrained </code>
类型: CLIPTextModel
的静态方法
models.CLIPTextModelWithProjection
CLIP 文本模型顶部带有投影层(在池化输出之上的线性层)
示例:使用 CLIPTextModelWithProjection
计算文本嵌入。
import { AutoTokenizer, CLIPTextModelWithProjection } from '@xenova/transformers';
// Load tokenizer and text model
const tokenizer = await AutoTokenizer.from_pretrained('Xenova/clip-vit-base-patch16');
const text_model = await CLIPTextModelWithProjection.from_pretrained('Xenova/clip-vit-base-patch16');
// Run tokenization
let texts = ['a photo of a car', 'a photo of a football match'];
let text_inputs = tokenizer(texts, { padding: true, truncation: true });
// Compute embeddings
const { text_embeds } = await text_model(text_inputs);
// Tensor {
// dims: [ 2, 512 ],
// type: 'float32',
// data: Float32Array(1024) [ ... ],
// size: 1024
// }
类型: models
的静态类
CLIPTextModelWithProjection.from_pretrained() : <code> PreTrainedModel.from_pretrained </code>
类型: CLIPTextModelWithProjection
的静态方法
models.CLIPVisionModel
CLIP 中的视觉模型,没有顶部任何头部或投影。
类型: models
的静态类
CLIPVisionModel.from_pretrained() : <code> PreTrainedModel.from_pretrained </code>
类型:CLIPVisionModel
的静态方法
models.CLIPVisionModelWithProjection
具有顶部投影层(池化输出上的线性层)的 CLIP 视觉模型
示例:使用 CLIPVisionModelWithProjection
计算视觉嵌入。
import { AutoProcessor, CLIPVisionModelWithProjection, RawImage} from '@xenova/transformers';
// Load processor and vision model
const processor = await AutoProcessor.from_pretrained('Xenova/clip-vit-base-patch16');
const vision_model = await CLIPVisionModelWithProjection.from_pretrained('Xenova/clip-vit-base-patch16');
// Read image and run processor
let image = await RawImage.read('https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/football-match.jpg');
let image_inputs = await processor(image);
// Compute embeddings
const { image_embeds } = await vision_model(image_inputs);
// Tensor {
// dims: [ 1, 512 ],
// type: 'float32',
// data: Float32Array(512) [ ... ],
// size: 512
// }
类型: models
的静态类
CLIPVisionModelWithProjection.from_pretrained() : <code> PreTrainedModel.from_pretrained </code>
类型:CLIPVisionModelWithProjection
的静态方法
models.SiglipModel
包含顶部投影层的 SigLIP 文本和视觉模型
示例:使用 SiglipModel
执行零样本图像分类。
import { AutoTokenizer, AutoProcessor, SiglipModel, RawImage } from '@xenova/transformers';
// Load tokenizer, processor, and model
const tokenizer = await AutoTokenizer.from_pretrained('Xenova/siglip-base-patch16-224');
const processor = await AutoProcessor.from_pretrained('Xenova/siglip-base-patch16-224');
const model = await SiglipModel.from_pretrained('Xenova/siglip-base-patch16-224');
// Run tokenization
const texts = ['a photo of 2 cats', 'a photo of 2 dogs'];
const text_inputs = tokenizer(texts, { padding: 'max_length', truncation: true });
// Read image and run processor
const image = await RawImage.read('http://images.cocodataset.org/val2017/000000039769.jpg');
const image_inputs = await processor(image);
// Run model with both text and pixel inputs
const output = await model({ ...text_inputs, ...image_inputs });
// {
// logits_per_image: Tensor {
// dims: [ 1, 2 ],
// data: Float32Array(2) [ -1.6019744873046875, -10.720091819763184 ],
// },
// logits_per_text: Tensor {
// dims: [ 2, 1 ],
// data: Float32Array(2) [ -1.6019744873046875, -10.720091819763184 ],
// },
// text_embeds: Tensor {
// dims: [ 2, 768 ],
// data: Float32Array(1536) [ ... ],
// },
// image_embeds: Tensor {
// dims: [ 1, 768 ],
// data: Float32Array(768) [ ... ],
// }
// }
类型: models
的静态类
models.SiglipTextModel
SigLIP中的文本模型,不含任何头部或投影。
示例:使用SiglipTextModel
计算文本嵌入。
import { AutoTokenizer, SiglipTextModel } from '@xenova/transformers';
// Load tokenizer and text model
const tokenizer = await AutoTokenizer.from_pretrained('Xenova/siglip-base-patch16-224');
const text_model = await SiglipTextModel.from_pretrained('Xenova/siglip-base-patch16-224');
// Run tokenization
const texts = ['a photo of 2 cats', 'a photo of 2 dogs'];
const text_inputs = tokenizer(texts, { padding: 'max_length', truncation: true });
// Compute embeddings
const { pooler_output } = await text_model(text_inputs);
// Tensor {
// dims: [ 2, 768 ],
// type: 'float32',
// data: Float32Array(1536) [ ... ],
// size: 1536
// }
类型: models
的静态类
SiglipTextModel.from_pretrained() : <code> PreTrainedModel.from_pretrained </code>
类型: SiglipTextModel
的静态方法
models.SiglipVisionModel
SigLIP中不含任何头部或投影的视觉模型。
示例:使用SiglipVisionModel
计算视觉嵌入。
import { AutoProcessor, SiglipVisionModel, RawImage} from '@xenova/transformers';
// Load processor and vision model
const processor = await AutoProcessor.from_pretrained('Xenova/siglip-base-patch16-224');
const vision_model = await SiglipVisionModel.from_pretrained('Xenova/siglip-base-patch16-224');
// Read image and run processor
const image = await RawImage.read('https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/football-match.jpg');
const image_inputs = await processor(image);
// Compute embeddings
const { pooler_output } = await vision_model(image_inputs);
// Tensor {
// dims: [ 1, 768 ],
// type: 'float32',
// data: Float32Array(768) [ ... ],
// size: 768
// }
类型: models
的静态类
SiglipVisionModel.from_pretrained() : <code> PreTrainedModel.from_pretrained </code>
类型: SiglipVisionModel
的静态方法
models.CLIPSegForImageSegmentation
CLIPSeg 模型,顶部采用了基于 Transformer 的解码器,可用于零样本和单样本图像分割。
示例:使用 CLIPSegForImageSegmentation
模型执行零样本图像分割。
import { AutoTokenizer, AutoProcessor, CLIPSegForImageSegmentation, RawImage } from '@xenova/transformers';
// Load tokenizer, processor, and model
const tokenizer = await AutoTokenizer.from_pretrained('Xenova/clipseg-rd64-refined');
const processor = await AutoProcessor.from_pretrained('Xenova/clipseg-rd64-refined');
const model = await CLIPSegForImageSegmentation.from_pretrained('Xenova/clipseg-rd64-refined');
// Run tokenization
const texts = ['a glass', 'something to fill', 'wood', 'a jar'];
const text_inputs = tokenizer(texts, { padding: true, truncation: true });
// Read image and run processor
const image = await RawImage.read('https://github.com/timojl/clipseg/blob/master/example_image.jpg?raw=true');
const image_inputs = await processor(image);
// Run model with both text and pixel inputs
const { logits } = await model({ ...text_inputs, ...image_inputs });
// logits: Tensor {
// dims: [4, 352, 352],
// type: 'float32',
// data: Float32Array(495616) [ ... ],
// size: 495616
// }
您可以使用以下方式可视化预测结果
const preds = logits
.unsqueeze_(1)
.sigmoid_()
.mul_(255)
.round_()
.to('uint8');
for (let i = 0; i < preds.dims[0]; ++i) {
const img = RawImage.fromTensor(preds[i]);
img.save(`prediction_${i}.png`);
}
类型: models
的静态类
models.GPT2PreTrainedModel
类型: models
的静态类
new GPT2PreTrainedModel(config, session, generation_config)
创建 GPT2PreTrainedModel
类的新实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型的配置。 |
session | 任意类型 | 包含模型权重的 ONNX 会话。 |
generation_config | GenerationConfig | 生成配置。 |
models.GPT2LMHeadModel
GPT-2 基础模型之上的语言模型头。此模型适用于文本生成任务。
类型: models
的静态类
models.GPTNeoPreTrainedModel
类型: models
的静态类
new GPTNeoPreTrainedModel(config, session, generation_config)
创建一个新的GPTNeoPreTrainedModel
实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型的配置。 |
session | 任意类型 | 包含模型权重的 ONNX 会话。 |
generation_config | GenerationConfig | 生成配置。 |
models.GPTNeoXPreTrainedModel
类型: models
的静态类
new GPTNeoXPreTrainedModel(config, session, generation_config)
创建一个新的GPTNeoXPreTrainedModel
实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型的配置。 |
session | 任意类型 | 包含模型权重的 ONNX 会话。 |
generation_config | GenerationConfig | 生成配置。 |
models.GPTJPreTrainedModel
类型: models
的静态类
new GPTJPreTrainedModel(config, session, generation_config)
创建一个 GPTJPreTrainedModel
类的新实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型的配置。 |
session | 任意类型 | 包含模型权重的 ONNX 会话。 |
generation_config | GenerationConfig | 生成配置。 |
models.GPTBigCodePreTrainedModel
类型: models
的静态类
new GPTBigCodePreTrainedModel(config, session, generation_config)
创建一个 GPTBigCodePreTrainedModel
类的新实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型的配置。 |
session | 任意类型 | 包含模型权重的 ONNX 会话。 |
generation_config | GenerationConfig | 生成配置。 |
models.CodeGenPreTrainedModel
类型: models
的静态类
new CodeGenPreTrainedModel(config, session, generation_config)
创建一个新的 CodeGenPreTrainedModel
类实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型配置对象。 |
session | 对象 | ONNX 会话对象。 |
generation_config | GenerationConfig | 生成配置。 |
models.CodeGenModel
CodeGenModel 是一个表示不带语言模型头的代码生成模型的类。
类型: models
的静态类
models.CodeGenForCausalLM
CodeGenForCausalLM 是一个基于 GPT-2 架构的代码生成模型类,它扩展了 CodeGenPreTrainedModel
类。
类型: models
的静态类
models.LlamaPreTrainedModel
LLama模型直接输出原始隐藏状态,未加上任何特定头。
类型: models
的静态类
new LlamaPreTrainedModel(config, session, generation_config)
创建一个LlamaPreTrainedModel
类的实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型配置对象。 |
session | 对象 | ONNX 会话对象。 |
generation_config | GenerationConfig | 生成配置。 |
models.LlamaModel
LLaMA模型直接输出原始隐藏状态,未加上任何特定头。
类型: models
的静态类
models.Qwen2PreTrainedModel
Qwen2模型直接输出原始隐藏状态,未加上任何特定头。
类型: models
的静态类
创建新的 Qwen2PreTrainedModel 对象(config, session, generation_config)
创建 Qwen2PreTrainedModel
类的新实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型配置对象。 |
session | 对象 | ONNX 会话对象。 |
generation_config | GenerationConfig | 生成配置。 |
models.Qwen2Model
Qwen2模型直接输出原始隐藏状态,未加上任何特定头。
类型: models
的静态类
models.PhiPreTrainedModel
类型: models
的静态类
创建新的 PhiPreTrainedModel 对象(config, session, generation_config)
创建 PhiPreTrainedModel
类的新实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型配置对象。 |
session | 对象 | ONNX 会话对象。 |
generation_config | GenerationConfig | 生成配置。 |
models.PhiModel
输出原始隐藏状态而不带有具体头部的裸Phi模型。
类型: models
的静态类
models.BloomPreTrainedModel
顶部带有语言模型头部的Bloom模型transformer。
类型: models
的静态类
new BloomPreTrainedModel(config, session, generation_config)
创建一个新的BloomPreTrainedModel
类实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型的配置。 |
session | 任意类型 | 包含模型权重的 ONNX 会话。 |
generation_config | GenerationConfig | 生成配置。 |
models.BloomModel
输出原始隐藏状态而不带有具体头部的裸Bloom模型transformer。
类型: models
的静态类
models.BloomForCausalLM
顶部带有语言模型头部的Bloom模型transformer。
类型: models
的静态类
models.MptPreTrainedModel
类型: models
的静态类
new MptPreTrainedModel(config, session, generation_config)
创建一个MptPreTrainedModel
类的实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型配置对象。 |
session | 对象 | ONNX 会话对象。 |
generation_config | GenerationConfig | 生成配置。 |
models.MptModel
一个裸露的Mpt模型变压器,输出原始隐藏状态,上面没有任何特定的头部。
类型: models
的静态类
models.MptForCausalLM
顶部带有语言建模头(具有输入嵌入权重关联的线性层)的MPT模型transformer。
类型: models
的静态类
models.OPTPreTrainedModel
类型: models
的静态类
new OPTPreTrainedModel(config, session, generation_config)
创建一个OPTPreTrainedModel
类的新实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型配置对象。 |
session | 对象 | ONNX 会话对象。 |
generation_config | GenerationConfig | 生成配置。 |
models.OPTModel
裸OPT模型,输出原始隐藏状态,顶部不带任何特定头。
类型: models
的静态类
models.OPTForCausalLM
OPT 模型变压器上面带有一个语言建模头(与输入嵌入权重相连接的线性层)。
类型: models
的静态类
models.VitMatteForImageMatting
ViTMatte 框架利用任何视觉骨干网络,例如用于 ADE20k、CityScapes。
示例: 使用 VitMatteForImageMatting
模型执行图像融合。
import { AutoProcessor, VitMatteForImageMatting, RawImage } from '@xenova/transformers';
// Load processor and model
const processor = await AutoProcessor.from_pretrained('Xenova/vitmatte-small-distinctions-646');
const model = await VitMatteForImageMatting.from_pretrained('Xenova/vitmatte-small-distinctions-646');
// Load image and trimap
const image = await RawImage.fromURL('https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/vitmatte_image.png');
const trimap = await RawImage.fromURL('https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/vitmatte_trimap.png');
// Prepare image + trimap for the model
const inputs = await processor(image, trimap);
// Predict alpha matte
const { alphas } = await model(inputs);
// Tensor {
// dims: [ 1, 1, 640, 960 ],
// type: 'float32',
// size: 614400,
// data: Float32Array(614400) [ 0.9894027709960938, 0.9970508813858032, ... ]
// }
您可以通过如下方式可视化灰度蒙版
import { Tensor, cat } from '@xenova/transformers';
// Visualize predicted alpha matte
const imageTensor = image.toTensor();
// Convert float (0-1) alpha matte to uint8 (0-255)
const alphaChannel = alphas
.squeeze(0)
.mul_(255)
.clamp_(0, 255)
.round_()
.to('uint8');
// Concatenate original image with predicted alpha
const imageData = cat([imageTensor, alphaChannel], 0);
// Save output image
const outputImage = RawImage.fromTensor(imageData);
outputImage.save('output.png');
类型: models
的静态类
vitMatteForImageMatting._call(model_inputs)
类型:VitMatteForImageMatting
的实例方法
参数 | 类型 |
---|---|
model_inputs | 任意类型 |
models.DetrObjectDetectionOutput
类型: models
的静态类
new DetrObjectDetectionOutput(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.logits | 张量(Tensor) | 所有查询的分类符号(包括无物体)。 |
output.pred_boxes | 张量(Tensor) | 所有查询的归一化方差坐标,表示为 (center_x, center_y, width, height)。这些值在 [0, 1] 范围内归一化,相对于批次中每个单独图像的大小(不考虑可能的填充)。 |
models.DetrSegmentationOutput
类型: models
的静态类
new DetrSegmentationOutput(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.logits | 张量(Tensor) | 模型的输出符号。 |
output.pred_boxes | 张量(Tensor) | 预测的框。 |
output.pred_masks | 张量(Tensor) | 预测的掩码。 |
models.TableTransformerModel
裸Tree Transformer模型(由骨干和编码器-解码器Transformer组成),输出原始隐藏状态,顶部没有任何具体头部。
类型: models
的静态类
models.TableTransformerForObjectDetection
表格变换模型(由骨干网络和编码器-解码器Transformer组成)并在其顶部添加目标检测头,适用于如COCO检测等任务。
类型: models
的静态类
tableTransformerForObjectDetection._call(model_inputs)
类型:TableTransformerForObjectDetection
的实例方法
参数 | 类型 |
---|---|
model_inputs | 任意类型 |
models.ResNetPreTrainedModel
一个抽象类,用于处理权重初始化以及下载和加载预训练模型的简单接口。
类型: models
的静态类
models.ResNetModel
不添加任何特定头的裸ResNet模型,输出原始特征。
类型: models
的静态类
models.ResNetForImageClassification
在图像分类头(在池化特征之上的线性层)之上的 ResNet 模型(例如,用于 ImageNet)。
类型: models
的静态类
resNetForImageClassification._call(model_inputs)
类型: ResNetForImageClassification
的实例方法
参数 | 类型 |
---|---|
model_inputs | 任意类型 |
models.Swin2SRModel
裸 Swin2SR 模型变压器,输出原始隐藏状态,顶部不带任何特定的头。
类型: models
的静态类
models.Swin2SRForImageSuperResolution
带有上采样头进行图像超分辨率和恢复的 Swin2SR 模型变压器。
示例:使用 Xenova/swin2SR-classical-sr-x2-64
进行超分辨率。
import { AutoProcessor, Swin2SRForImageSuperResolution, RawImage } from '@xenova/transformers';
// Load processor and model
const model_id = 'Xenova/swin2SR-classical-sr-x2-64';
const processor = await AutoProcessor.from_pretrained(model_id);
const model = await Swin2SRForImageSuperResolution.from_pretrained(model_id);
// Prepare model inputs
const url = 'https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/butterfly.jpg';
const image = await RawImage.fromURL(url);
const inputs = await processor(image);
// Run model
const outputs = await model(inputs);
// Convert Tensor to RawImage
const output = outputs.reconstruction.squeeze().clamp_(0, 1).mul_(255).round_().to('uint8');
const outputImage = RawImage.fromTensor(output);
// RawImage {
// data: Uint8Array(786432) [ 41, 31, 24, ... ],
// width: 512,
// height: 512,
// channels: 3
// }
类型: models
的静态类
models.DPTModel
无特定头部输出的原始隐藏状态的裸DPT模型。
类型: models
的静态类
models.DPTForDepthEstimation
顶部带有深度估计头(由3个卷积层组成)的DPT模型,例如用于KITTI、NYUv2。
示例:使用 Xenova/dpt-hybrid-midas
进行深度估计。
import { DPTForDepthEstimation, AutoProcessor, RawImage, interpolate, max } from '@xenova/transformers';
// Load model and processor
const model_id = 'Xenova/dpt-hybrid-midas';
const model = await DPTForDepthEstimation.from_pretrained(model_id);
const processor = await AutoProcessor.from_pretrained(model_id);
// Load image from URL
const url = 'http://images.cocodataset.org/val2017/000000039769.jpg';
const image = await RawImage.fromURL(url);
// Prepare image for the model
const inputs = await processor(image);
// Run model
const { predicted_depth } = await model(inputs);
// Interpolate to original size
const prediction = interpolate(predicted_depth, image.size.reverse(), 'bilinear', false);
// Visualize the prediction
const formatted = prediction.mul_(255 / max(prediction.data)[0]).to('uint8');
const depth = RawImage.fromTensor(formatted);
// RawImage {
// data: Uint8Array(307200) [ 85, 85, 84, ... ],
// width: 640,
// height: 480,
// channels: 1
// }
类型: models
的静态类
models.DepthAnythingForDepthEstimation
顶部带有由3个卷积层组成的深度估计头的Depth Anything模型,例如用于KITTI、NYUv2。
类型: models
的静态类
models.GLPNModel
无任何特定头部输出的裸GLPN编码器(Mix-Transformer)的原始隐藏状态。
类型: models
的静态类
models.GLPNForDepthEstimation
在顶部具有轻量级深度估计头的GLPN模型转换器,例如用于KITTI、NYUv2。
示例:使用 Xenova/glpn-kitti
进行深度估计。
import { GLPNForDepthEstimation, AutoProcessor, RawImage, interpolate, max } from '@xenova/transformers';
// Load model and processor
const model_id = 'Xenova/glpn-kitti';
const model = await GLPNForDepthEstimation.from_pretrained(model_id);
const processor = await AutoProcessor.from_pretrained(model_id);
// Load image from URL
const url = 'http://images.cocodataset.org/val2017/000000039769.jpg';
const image = await RawImage.fromURL(url);
// Prepare image for the model
const inputs = await processor(image);
// Run model
const { predicted_depth } = await model(inputs);
// Interpolate to original size
const prediction = interpolate(predicted_depth, image.size.reverse(), 'bilinear', false);
// Visualize the prediction
const formatted = prediction.mul_(255 / max(prediction.data)[0]).to('uint8');
const depth = RawImage.fromTensor(formatted);
// RawImage {
// data: Uint8Array(307200) [ 207, 169, 154, ... ],
// width: 640,
// height: 480,
// channels: 1
// }
类型: models
的静态类
models.DonutSwinModel
裸露的Donut Swin Model转换器,输出原始隐藏状态,顶部不带任何特定的头。
示例:文档解析步骤。
import { AutoProcessor, AutoTokenizer, AutoModelForVision2Seq, RawImage } from '@xenova/transformers';
// Choose model to use
const model_id = 'Xenova/donut-base-finetuned-cord-v2';
// Prepare image inputs
const processor = await AutoProcessor.from_pretrained(model_id);
const url = 'https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/receipt.png';
const image = await RawImage.read(url);
const image_inputs = await processor(image);
// Prepare decoder inputs
const tokenizer = await AutoTokenizer.from_pretrained(model_id);
const task_prompt = '<s_cord-v2>';
const decoder_input_ids = tokenizer(task_prompt, {
add_special_tokens: false,
}).input_ids;
// Create the model
const model = await AutoModelForVision2Seq.from_pretrained(model_id);
// Run inference
const output = await model.generate(image_inputs.pixel_values, {
decoder_input_ids,
max_length: model.config.decoder.max_position_embeddings,
});
// Decode output
const decoded = tokenizer.batch_decode(output)[0];
// <s_cord-v2><s_menu><s_nm> CINNAMON SUGAR</s_nm><s_unitprice> 17,000</s_unitprice><s_cnt> 1 x</s_cnt><s_price> 17,000</s_price></s_menu><s_sub_total><s_subtotal_price> 17,000</s_subtotal_price></s_sub_total><s_total><s_total_price> 17,000</s_total_price><s_cashprice> 20,000</s_cashprice><s_changeprice> 3,000</s_changeprice></s_total></s>
示例:文档视觉问答(DocVQA)步骤。
import { AutoProcessor, AutoTokenizer, AutoModelForVision2Seq, RawImage } from '@xenova/transformers';
// Choose model to use
const model_id = 'Xenova/donut-base-finetuned-docvqa';
// Prepare image inputs
const processor = await AutoProcessor.from_pretrained(model_id);
const url = 'https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/invoice.png';
const image = await RawImage.read(url);
const image_inputs = await processor(image);
// Prepare decoder inputs
const tokenizer = await AutoTokenizer.from_pretrained(model_id);
const question = 'What is the invoice number?';
const task_prompt = `<s_docvqa><s_question>${question}</s_question><s_answer>`;
const decoder_input_ids = tokenizer(task_prompt, {
add_special_tokens: false,
}).input_ids;
// Create the model
const model = await AutoModelForVision2Seq.from_pretrained(model_id);
// Run inference
const output = await model.generate(image_inputs.pixel_values, {
decoder_input_ids,
max_length: model.config.decoder.max_position_embeddings,
});
// Decode output
const decoded = tokenizer.batch_decode(output)[0];
// <s_docvqa><s_question> What is the invoice number?</s_question><s_answer> us-001</s_answer></s>
类型: models
的静态类
models.ConvNextModel
裸露的ConvNext模型,输出原始特征,顶部不带任何特定的头。
类型: models
的静态类
models.ConvNextForImageClassification
ConvNext模型,顶部带有图像分类头(在池化特征之上的线性层),例如用于ImageNet。
类型: models
的静态类
convNextForImageClassification._call(model_inputs)
类型:类《ConvNextForImageClassification
》的实例方法
参数 | 类型 |
---|---|
model_inputs | 任意类型 |
models.ConvNextV2Model
裸的ConvNextV2模型,输出原始特征,顶部不带任何特定的头。
类型: models
的静态类
models.ConvNextV2ForImageClassification
顶部的图像分类头(在池化特征之上的一层线性层)之上的ConvNextV2模型,例如用于ImageNet。
类型: models
的静态类
convNextV2ForImageClassification._call(model_inputs)
类型:类《ConvNextV2ForImageClassification
》的实例方法
参数 | 类型 |
---|---|
model_inputs | 任意类型 |
models.Dinov2Model
不带任何特定头部的DINOv2模型transformer,输出原始的hidden-states。
类型: models
的静态类
models.Dinov2ForImageClassification
在顶部带有一个图像分类头的DinoV2模型Transformer(在[CLS] token的最后隐藏状态之上的线性层),例如用于ImageNet。
类型: models
的静态类
dinov2ForImageClassification._call(model_inputs)
类型: Dinov2ForImageClassification
的实例方法
参数 | 类型 |
---|---|
model_inputs | 任意类型 |
models.YolosObjectDetectionOutput
类型: models
的静态类
new YolosObjectDetectionOutput(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.logits | 张量(Tensor) | 所有查询的分类符号(包括无物体)。 |
output.pred_boxes | 张量(Tensor) | 所有查询的归一化方差坐标,表示为 (center_x, center_y, width, height)。这些值在 [0, 1] 范围内归一化,相对于批次中每个单独图像的大小(不考虑可能的填充)。 |
models.SamModel
Segment Anything Model (SAM)用于根据输入图像和可选的2D位置和边界框生成分割掩码。
示例:使用Xenova/sam-vit-base
执行掩码生成。
import { SamModel, AutoProcessor, RawImage } from '@xenova/transformers';
const model = await SamModel.from_pretrained('Xenova/sam-vit-base');
const processor = await AutoProcessor.from_pretrained('Xenova/sam-vit-base');
const img_url = 'https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png';
const raw_image = await RawImage.read(img_url);
const input_points = [[[450, 600]]] // 2D localization of a window
const inputs = await processor(raw_image, input_points);
const outputs = await model(inputs);
const masks = await processor.post_process_masks(outputs.pred_masks, inputs.original_sizes, inputs.reshaped_input_sizes);
// [
// Tensor {
// dims: [ 1, 3, 1764, 2646 ],
// type: 'bool',
// data: Uint8Array(14002632) [ ... ],
// size: 14002632
// }
// ]
const scores = outputs.iou_scores;
// Tensor {
// dims: [ 1, 1, 3 ],
// type: 'float32',
// data: Float32Array(3) [
// 0.8892380595207214,
// 0.9311248064041138,
// 0.983696699142456
// ],
// size: 3
// }
类型: models
的静态类
- .Sam模型
new Sam模型(config, 视觉编码器, 提示编码器掩码解码器)
.get_image_embeddings(model_inputs)
⇒Promise.<{image_embeddings: Tensor, image_positional_embeddings: Tensor}>
.forward(model_inputs)
⇒Promise.<Object>
._call(model_inputs)
⇒Promise.<SamImageSegmentationOutput>
new SamModel(config, vision_encoder, prompt_encoder_mask_decoder)
创建一个新的SamModel类的实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 指定超参数和其他模型设置的配置对象。 |
vision_encoder | 对象 | 包含视觉编码器模型的ONNX会话。 |
prompt_encoder_mask_decoder | 任意类型 | 包含提示编码器和掩码解码器的ONNX会话。 |
samModel.get_image_embeddings(model_inputs) ⇒ <code> Promise. < {image_embeddings: Tensor, image_positional_embeddings: Tensor} > </code>
根据图像的像素值计算图像嵌入和位置嵌入。
类型:SamModel
的实例方法
返回值:Promise.<{image_embeddings: Tensor, image_positional_embeddings: Tensor}>
- 图像嵌入和位置嵌入。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 包含模型输入的对象。 |
model_inputs.pixel_values | 张量(Tensor) | 使用 |
有关 Promise.<Object>
和其使用的详细信息,请参阅 这里。
类型:SamModel
的实例方法
返回值:Promise.<Object>
- 模型的输出。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | SamModelInputs | 包含模型输入的对象。 |
有关 Promise.<SamImageSegmentationOutput>
和其使用的详细信息,请参阅 这里。
使用提供的输入运行模型
类型:SamModel
的实例方法
返回值:Promise.<SamImageSegmentationOutput>
- 包含分割输出的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型输入 |
有关 models.SamImageSegmentationOutput
的详细信息,请参阅 这里。
Segment-Anything 模型输出的基类。
类型: models
的静态类
new SamImageSegmentationOutput(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.iou_scores | 张量(Tensor) | 模型的输出符号。 |
output.pred_masks | 张量(Tensor) | 预测的框。 |
models.MarianMTModel
类型: models
的静态类
new MarianMTModel(config, session, decoder_merged_session, generation_config)
创建一个 MarianMTModel
类的新实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型配置对象。 |
session | 对象 | ONNX 会话对象。 |
decoder_merged_session | 任意类型 | |
generation_config | 任意类型 |
models.M2M100ForConditionalGeneration
类型: models
的静态类
new M2M100ForConditionalGeneration(config, session, decoder_merged_session, generation_config)
创建一个新的M2M100ForConditionalGeneration
类的实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型配置对象。 |
session | 对象 | ONNX 会话对象。 |
decoder_merged_session | 任意类型 | |
generation_config | 任意类型 |
models.Wav2Vec2Model
原始Wav2Vec2模型transformer,输出原始隐藏状态,没有添加任何特定的头部。
示例: 加载并运行一个Wav2Vec2Model
用于特征提取。
import { AutoProcessor, AutoModel, read_audio } from '@xenova/transformers';
// Read and preprocess audio
const processor = await AutoProcessor.from_pretrained('Xenova/mms-300m');
const audio = await read_audio('https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac', 16000);
const inputs = await processor(audio);
// Run model with inputs
const model = await AutoModel.from_pretrained('Xenova/mms-300m');
const output = await model(inputs);
// {
// last_hidden_state: Tensor {
// dims: [ 1, 1144, 1024 ],
// type: 'float32',
// data: Float32Array(1171456) [ ... ],
// size: 1171456
// }
// }
类型: models
的静态类
models.Wav2Vec2ForAudioFrameClassification
在Wav2Vec2模型顶部添加帧分类头部,用于说话人分段等任务。
类型: models
的静态类
wav2Vec2ForAudioFrameClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型: Wav2Vec2ForAudioFrameClassification
的实例方法
返回值: Promise.<TokenClassifierOutput>
- 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.UniSpeechModel
裸UniSpeech模型,输出原始隐藏状态,没有顶部任何特定的头。
类型: models
的静态类
models.UniSpeechForCTC
UniSpeech模型顶部带有语言模型
头,用于连接主义时序分类(CTC)。
类型: models
的静态类
uniSpeechForCTC._call(model_inputs)
类型: UniSpeechForCTC
的实例方法
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | |
model_inputs.input_values | 张量(Tensor) | 输入原始语音波形浮点数值。 |
model_inputs.attention_mask | 张量(Tensor) | 避免在填充标记索引处执行卷积和注意力计算的掩码。掩码值在 [0, 1] 之间。 |
models.UniSpeechForSequenceClassification
在顶部带有序列分类头部的 UniSpeech 模型(在池化输出上有一个线性层)。
类型: models
的静态类
uniSpeechForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型: UniSpeechForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.UniSpeechSatModel
没有顶部特定头部的裸 UniSpeechSat 模型,输出原始隐藏状态。
类型: models
的静态类
models.UniSpeechSatForCTC
UniSpeechSat 模型,顶部带有 语言模型
头部以进行连接时序分类(CTC)。
类型: models
的静态类
uniSpeechSatForCTC._call(model_inputs)
类型: UniSpeechSatForCTC
的实例方法
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | |
model_inputs.input_values | 张量(Tensor) | 输入原始语音波形浮点数值。 |
model_inputs.attention_mask | 张量(Tensor) | 避免在填充标记索引处执行卷积和注意力计算的掩码。掩码值在 [0, 1] 之间。 |
models.UniSpeechSatForSequenceClassification
UniSpeechSat 模型,顶部带有序列分类头(一个叠加在池化输出上的线性层)。
类型: models
的静态类
uniSpeechSatForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型: UniSpeechSatForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.UniSpeechSatForAudioFrameClassification
UniSpeechSat模型,顶部有框架分类头,适用于如说话人分割等任务。
类型: models
的静态类
uniSpeechSatForAudioFrameClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型:类方法 UniSpeechSatForAudioFrameClassification
返回值: Promise.<TokenClassifierOutput>
- 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.Wav2Vec2BertModel
裸Wav2Vec2Bert模型,输出原始隐藏状态,顶部没有特定头。
类型: models
的静态类
models.Wav2Vec2BertForCTC
在Wav2Vec2Bert模型顶部添加了《code 语言建模》头,用于时序连接分类(CTC)。
类型: models
的静态类
wav2Vec2BertForCTC._call(model_inputs)
类型:类方法 Wav2Vec2BertForCTC
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | |
model_inputs.input_features | 张量(Tensor) | 输入梅尔频谱图的特征浮点值。 |
model_inputs.attention_mask | 张量(Tensor) | 避免在填充标记索引处执行卷积和注意力计算的掩码。掩码值在 [0, 1] 之间。 |
models.Wav2Vec2BertForSequenceClassification
在Wav2Vec2Bert模型顶部添加序列分类头(在池化输出上的线性层)。
类型: models
的静态类
wav2Vec2BertForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型:类方法 Wav2Vec2BertForSequenceClassification
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.HubertModel
仅输出原始隐藏状态的裸Hubert模型,顶部没有特定的头部。
示例:加载并运行用于特征提取的HubertModel
。
import { AutoProcessor, AutoModel, read_audio } from '@xenova/transformers';
// Read and preprocess audio
const processor = await AutoProcessor.from_pretrained('Xenova/hubert-base-ls960');
const audio = await read_audio('https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/jfk.wav', 16000);
const inputs = await processor(audio);
// Load and run model with inputs
const model = await AutoModel.from_pretrained('Xenova/hubert-base-ls960');
const output = await model(inputs);
// {
// last_hidden_state: Tensor {
// dims: [ 1, 549, 768 ],
// type: 'float32',
// data: Float32Array(421632) [0.0682469978928566, 0.08104046434164047, -0.4975186586380005, ...],
// size: 421632
// }
// }
类型: models
的静态类
models.HubertForCTC
顶部有面向连接时序分类(CTC)的语言建模头部的Hubert模型。
类型: models
的静态类
hubertForCTC._call(model_inputs)
类型:类HubertForCTC
的实例方法
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | |
model_inputs.input_values | 张量(Tensor) | 输入原始语音波形浮点数值。 |
model_inputs.attention_mask | 张量(Tensor) | 避免在填充标记索引处执行卷积和注意力计算的掩码。掩码值在 [0, 1] 之间。 |
models.HubertForSequenceClassification
顶部有一个序列分类头部(池化输出的线性层)的Hubert模型,用于像SUPERB关键词检测这样的任务。
类型: models
的静态类
hubertForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型: HubertForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.WavLMPreTrainedModel
一个抽象类,用于处理权重初始化以及下载和加载预训练模型的简单接口。
类型: models
的静态类
models.WavLMModel
一个无特定头部的 WavLM 模型,输出原始隐藏状态。
示例: 加载并运行一个 WavLMModel
以进行特征提取。
import { AutoProcessor, AutoModel, read_audio } from '@xenova/transformers';
// Read and preprocess audio
const processor = await AutoProcessor.from_pretrained('Xenova/wavlm-base');
const audio = await read_audio('https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/jfk.wav', 16000);
const inputs = await processor(audio);
// Run model with inputs
const model = await AutoModel.from_pretrained('Xenova/wavlm-base');
const output = await model(inputs);
// {
// last_hidden_state: Tensor {
// dims: [ 1, 549, 768 ],
// type: 'float32',
// data: Float32Array(421632) [-0.349443256855011, -0.39341306686401367, 0.022836603224277496, ...],
// size: 421632
// }
// }
类型: models
的静态类
models.WavLMForCTC
在 WavLM 模型顶端添加基于 语言建模
的头部,用于连接主义时序分类 (CTC)。
类型: models
的静态类
wavLMForCTC._call(model_inputs)
类型: WavLMForCTC
的实例方法
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | |
model_inputs.input_values | 张量(Tensor) | 输入原始语音波形浮点数值。 |
model_inputs.attention_mask | 张量(Tensor) | 避免在填充标记索引处执行卷积和注意力计算的掩码。掩码值在 [0, 1] 之间。 |
models.WavLMForSequenceClassification
在顶部具有序列分类头(在池化输出上的线性层)的 WavLM 模型。
类型: models
的静态类
wavLMForSequenceClassification._call(model_inputs) → <code> Promise. < SequenceClassifierOutput > </code>
在新的输入上调用模型。
类型: WavLMForSequenceClassification
的实例方法
返回值:返回 <code>Promise.<SequenceClassifierOutput></code> - 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.WavLMForXVector
顶部具有 XVector 特征提取头部的 WavLM 模型,用于如说话人验证等任务。
示例:使用 WavLMForXVector
提取说话人嵌入。
import { AutoProcessor, AutoModel, read_audio } from '@xenova/transformers';
// Read and preprocess audio
const processor = await AutoProcessor.from_pretrained('Xenova/wavlm-base-plus-sv');
const url = 'https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/jfk.wav';
const audio = await read_audio(url, 16000);
const inputs = await processor(audio);
// Run model with inputs
const model = await AutoModel.from_pretrained('Xenova/wavlm-base-plus-sv');
const outputs = await model(inputs);
// {
// logits: Tensor {
// dims: [ 1, 512 ],
// type: 'float32',
// data: Float32Array(512) [0.5847219228744507, ...],
// size: 512
// },
// embeddings: Tensor {
// dims: [ 1, 512 ],
// type: 'float32',
// data: Float32Array(512) [-0.09079201519489288, ...],
// size: 512
// }
// }
类型: models
的静态类
wavLMForXVector._call(model_inputs) ⇒ <code> Promise. < XVectorOutput > </code>
在新的输入上调用模型。
类型: WavLMForXVector
的实例方法
返回: Promise.<XVectorOutput>
- 包含模型输出 logits 和说话人嵌入的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.WavLMForAudioFrameClassification
带有帧分类头的 WavLM 模型,适用于说话人去混叠等任务。
示例: 使用 WavLMForAudioFrameClassification
进行说话人去混叠。
import { AutoProcessor, AutoModelForAudioFrameClassification, read_audio } from '@xenova/transformers';
// Read and preprocess audio
const processor = await AutoProcessor.from_pretrained('Xenova/wavlm-base-plus-sd');
const url = 'https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/jfk.wav';
const audio = await read_audio(url, 16000);
const inputs = await processor(audio);
// Run model with inputs
const model = await AutoModelForAudioFrameClassification.from_pretrained('Xenova/wavlm-base-plus-sd');
const { logits } = await model(inputs);
// {
// logits: Tensor {
// dims: [ 1, 549, 2 ], // [batch_size, num_frames, num_speakers]
// type: 'float32',
// data: Float32Array(1098) [-3.5301010608673096, ...],
// size: 1098
// }
// }
const labels = logits[0].sigmoid().tolist().map(
frames => frames.map(speaker => speaker > 0.5 ? 1 : 0)
);
console.log(labels); // labels is a one-hot array of shape (num_frames, num_speakers)
// [
// [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0],
// [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0],
// [0, 0], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1],
// ...
// ]
类型: models
的静态类
wavLMForAudioFrameClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>
在新的输入上调用模型。
类型: WavLMForAudioFrameClassification
的实例方法
返回值: Promise.<TokenClassifierOutput>
- 包含模型序列分类输出 logit 的对象。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.SpeechT5PreTrainedModel
一个抽象类,用于处理权重初始化以及下载和加载预训练模型的简单接口。
类型: models
的静态类
models.SpeechT5Model
未经过任何特定预处理或后处理的裸SpeechT5编码器-解码器模型,输出原始隐藏状态。
类型: models
的静态类
models.SpeechT5ForSpeechToText
具有语音编码器和文本解码器的SpeechT5模型。
示例: 使用SpeechT5ForSpeechToText
生成文本的语音。
import { AutoTokenizer, AutoProcessor, SpeechT5ForTextToSpeech, SpeechT5HifiGan, Tensor } from '@xenova/transformers';
// Load the tokenizer and processor
const tokenizer = await AutoTokenizer.from_pretrained('Xenova/speecht5_tts');
const processor = await AutoProcessor.from_pretrained('Xenova/speecht5_tts');
// Load the models
// NOTE: We use the unquantized versions as they are more accurate
const model = await SpeechT5ForTextToSpeech.from_pretrained('Xenova/speecht5_tts', { quantized: false });
const vocoder = await SpeechT5HifiGan.from_pretrained('Xenova/speecht5_hifigan', { quantized: false });
// Load speaker embeddings from URL
const speaker_embeddings_data = new Float32Array(
await (await fetch('https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/speaker_embeddings.bin')).arrayBuffer()
);
const speaker_embeddings = new Tensor(
'float32',
speaker_embeddings_data,
[1, speaker_embeddings_data.length]
)
// Run tokenization
const { input_ids } = tokenizer('Hello, my dog is cute');
// Generate waveform
const { waveform } = await model.generate_speech(input_ids, speaker_embeddings, { vocoder });
console.log(waveform)
// Tensor {
// dims: [ 26112 ],
// type: 'float32',
// size: 26112,
// data: Float32Array(26112) [ -0.00043630177970044315, -0.00018082228780258447, ... ],
// }
类型: models
的静态类
models.SpeechT5ForTextToSpeech
具有文本编码器和语音解码器的SpeechT5模型。
类型: models
的静态类
new SpeechT5ForTextToSpeech(config, session, decoder_merged_session, generation_config)
创建一个新的SpeechT5ForTextToSpeech
类实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型配置。 |
session | 任意类型 | 模型的会话。 |
decoder_merged_session | 任意类型 | 解码器的session。 |
generation_config | GenerationConfig | 生成配置。 |
speechT5ForTextToSpeech.generate_speech(input_values, speaker_embeddings, options) → Promise.
将输入序列标记转换为梅尔频谱序列,然后使用声码器将其转换为语音波形。
类型: SpeechT5ForTextToSpeech
的实例方法
返回值: Promise.<SpeechOutput>
- 一个承诺,解析为包含频谱、波形和交叉注意力张量的对象。
参数 | 类型 | 默认 | 说明 |
---|---|---|---|
input_values | 张量(Tensor) | 词汇表中的输入序列标记索引。 | |
speaker_embeddings | 张量(Tensor) | 包含说话者嵌入的张量。 | |
options | 对象 | 生成语音的可选参数。 | |
[options.threshold] | 数字 | 0.5 | 当预测的停止标记概率超过此值时,生成的序列结束。 |
[options.minlenratio] | 数字 | 0.0 | 用于计算输出序列所需的最小长度。 |
[options.maxlenratio] | 数字 | 20.0 | 用于计算输出序列的最大允许长度。 |
[options.vocoder] | 对象 |
| 将梅尔频谱转换为语音波形的声码器。如果为 |
[options.output_cross_attentions] | 布尔值 | false | 是否返回解码器交叉注意力层的注意力张量。 |
models.SpeechT5HifiGan
HiFi-GAN声码器。
有关示例用法,请参阅 SpeechT5ForSpeechToText。
类型: models
的静态类
models.TrOCRPreTrainedModel
类型: models
的静态类
new TrOCRPreTrainedModel(config, session, generation_config)
创建一个新的 TrOCRPreTrainedModel
类实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型的配置。 |
session | 任意类型 | 包含模型权重的 ONNX 会话。 |
generation_config | GenerationConfig | 生成配置。 |
models.TrOCRForCausalLM
具有语言建模头的 TrOCR 解码器。
类型: models
的静态类
models.MistralPreTrainedModel
无特定头输出的原始隐藏状态的裸Mistral模型。
类型: models
的静态类
new MistralPreTrainedModel(配置, 会话, 生成配置)
创建一个新的 MistralPreTrainedModel
类实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型的配置。 |
session | 任意类型 | 包含模型权重的 ONNX 会话。 |
generation_config | GenerationConfig | 生成配置。 |
models.Starcoder2PreTrainedModel
裸星Coder2模型输出原始隐藏状态,顶部不带任何特定头部。
类型: models
的静态类
new Starcoder2PreTrainedModel(配置, 会话, 生成配置)
创建一个新的 Starcoder2PreTrainedModel
类实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型的配置。 |
session | 任意类型 | 包含模型权重的 ONNX 会话。 |
generation_config | GenerationConfig | 生成配置。 |
models.FalconPreTrainedModel
裸Falcon模型输出原始隐藏状态,顶部不带任何特定头部。
类型: models
的静态类
new FalconPreTrainedModel(config, session, generation_config)
创建一个新的 FalconPreTrainedModel
类实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型的配置。 |
session | 任意类型 | 包含模型权重的 ONNX 会话。 |
generation_config | GenerationConfig | 生成配置。 |
models.ClapTextModelWithProjection
在文本模型顶部添加投影层(在池化输出之上加一个线性层)的 CLAP 文本模型。
示例: 使用 ClapTextModelWithProjection
计算文本嵌入。
import { AutoTokenizer, ClapTextModelWithProjection } from '@xenova/transformers';
// Load tokenizer and text model
const tokenizer = await AutoTokenizer.from_pretrained('Xenova/clap-htsat-unfused');
const text_model = await ClapTextModelWithProjection.from_pretrained('Xenova/clap-htsat-unfused');
// Run tokenization
const texts = ['a sound of a cat', 'a sound of a dog'];
const text_inputs = tokenizer(texts, { padding: true, truncation: true });
// Compute embeddings
const { text_embeds } = await text_model(text_inputs);
// Tensor {
// dims: [ 2, 512 ],
// type: 'float32',
// data: Float32Array(1024) [ ... ],
// size: 1024
// }
类型: models
的静态类
ClapTextModelWithProjection.from_pretrained() : <code> PreTrainedModel.from_pretrained </code>
方法类型:ClapTextModelWithProjection
的静态方法
models.ClapAudioModelWithProjection
具有投影层(在池化输出之上的线性层)的CLAP音频模型。
示例:使用 ClapAudioModelWithProjection
计算音频嵌入。
import { AutoProcessor, ClapAudioModelWithProjection, read_audio } from '@xenova/transformers';
// Load processor and audio model
const processor = await AutoProcessor.from_pretrained('Xenova/clap-htsat-unfused');
const audio_model = await ClapAudioModelWithProjection.from_pretrained('Xenova/clap-htsat-unfused');
// Read audio and run processor
const audio = await read_audio('https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/cat_meow.wav');
const audio_inputs = await processor(audio);
// Compute embeddings
const { audio_embeds } = await audio_model(audio_inputs);
// Tensor {
// dims: [ 1, 512 ],
// type: 'float32',
// data: Float32Array(512) [ ... ],
// size: 512
// }
类型: models
的静态类
ClapAudioModelWithProjection.from_pretrained() : <code> PreTrainedModel.from_pretrained </code>
类型: ClapAudioModelWithProjection
的静态方法
models.VitsModel
完整的VITS模型,用于文本到语音合成。
示例:使用 从文本生成语音。
import { AutoTokenizer, VitsModel } from '@xenova/transformers';
// Load the tokenizer and model
const tokenizer = await AutoTokenizer.from_pretrained('Xenova/mms-tts-eng');
const model = await VitsModel.from_pretrained('Xenova/mms-tts-eng');
// Run tokenization
const inputs = tokenizer('I love transformers');
// Generate waveform
const { waveform } = await model(inputs);
// Tensor {
// dims: [ 1, 35328 ],
// type: 'float32',
// data: Float32Array(35328) [ ... ],
// size: 35328,
// }
类型: models
的静态类
vitsModel._call(model_inputs) → <code> Promise. < VitsModelOutput > </code>
在新的输入上调用模型。
类型: VitsModel
的实例方法
返回值: Promise.<VitsModelOutput>
- VITS模型的输出。
参数 | 类型 | 说明 |
---|---|---|
model_inputs | 对象 | 模型的输入。 |
models.SegformerModel
裸露的 SegFormer 编码器(Mix-Transformer),在不添加任何特定头的情况下输出原始的隐藏状态。
类型: models
的静态类
models.SegformerForImageClassification
在顶层添加图像分类头部的 SegFormer 模型转换器(最后隐藏状态的线性层)等,例如用于 ImageNet。
类型: models
的静态类
models.SegformerForSemanticSegmentation
在顶层添加全 MLP 解码头的 SegFormer 模型转换器等,例如用于 ADE20k、CityScapes。
类型: models
的静态类
models.StableLmPreTrainedModel
类型: models
的静态类
new StableLmPreTrainedModel(config, session, generation_config)
创建了一个新的 StableLmPreTrainedModel
类实例。
参数 | 类型 | 说明 |
---|---|---|
config | 对象 | 模型的配置。 |
session | 任意类型 | 包含模型权重的 ONNX 会话。 |
generation_config | GenerationConfig | 生成配置。 |
models.StableLmModel
裸露的 StableLm 模型,输出原始隐藏状态,不带有任何特定头部。
类型: models
的静态类
models.StableLmForCausalLM
在顶部添加了 language modeling
头部的 StableLm 模型,用于因因果语言建模(带时间顺序的)。
类型: models
的静态类
models.EfficientNetModel
裸露的 EfficientNet 模型,输出原始特征,不带有任何特定头部。
类型: models
的静态类
models.EfficientNetForImageClassification
在图像分类顶部具有图像分类头的EfficientNet模型(在池化特征之上的一层线性层)。
类型: models
的静态类
efficientNetForImageClassification._call(model_inputs)
类型:类EfficientNetForImageClassification
的实例方法
参数 | 类型 |
---|---|
model_inputs | 任意类型 |
models.DecisionTransformerModel
该模型基于GPT2架构,在离线强化学习环境中执行自动回归动作预测。更多详细信息请参阅论文:[https://arxiv.org/abs/2106.01345](https://arxiv.org/abs/2106.01345)
类型: models
的静态类
models.PretrainedMixin
所有AutoModel的基类。包含用于实例化预训练模型的from_pretrained
函数。
类型: models
的静态类
- .PretrainedMixin
- 实例
- 静态
.from_pretrained()
:PreTrainedModel.from_pretrained
pretrainedMixin.MODEL_CLASS_MAPPINGS : <code> * </code>
模型类型到模型类的映射。
类型: PretrainedMixin
的实例属性
pretrainedMixin.BASE_IF_FAIL
当模型类型在映射中未找到时,是否尝试实例化基类(PretrainedModel
)。
类型: PretrainedMixin
的实例属性
PretrainedMixin.from_pretrained() : <code> PreTrainedModel.from_pretrained </code>
类型: PretrainedMixin
的静态方法
models.AutoModel
用于使用 from_pretrained
函数实例化预训练模型的辅助类。所选模型类由模型配置中指定的类型决定。
类型: models
的静态类
autoModel.MODEL_CLASS_MAPPINGS : <code> * </code>
类型: AutoModel
的实例属性
models.AutoModelForSequenceClassification
这是一个实用类,用于使用 from_pretrained
函数实例化预训练的序列分类模型。模型类别由模型配置中指定的类型决定。
类型: models
的静态类
models.AutoModelForTokenClassification
这是一个实用类,用于使用 from_pretrained
函数实例化预训练的标记分类模型。模型类别由模型配置中指定的类型决定。
类型: models
的静态类
models.AutoModelForSeq2SeqLM
这是一个实用类,用于使用 from_pretrained
函数实例化预训练的序列到序列模型。模型类别由模型配置中指定的类型决定。
类型: models
的静态类
models.AutoModelForSpeechSeq2Seq
辅助类,用于使用from_pretrained
函数实例化预训练的序列到序列语音到文本模型。选择的模型类由模型配置中指定的类型确定。
类型: models
的静态类
models.AutoModelForTextToSpectrogram
辅助类,用于使用from_pretrained
函数实例化预训练的序列到序列文本到频谱图模型。选择的模型类由模型配置中指定的类型确定。
类型: models
的静态类
models.AutoModelForTextToWaveform
辅助类,用于使用from_pretrained
函数实例化预训练的文本到波形模型。选择的模型类由模型配置中指定的类型确定。
类型: models
的静态类
models.AutoModelForCausalLM
使用from_pretrained
函数实例化预训练因果语言模型的辅助类。所选模型类由模型配置中指定的类型决定。
类型: models
的静态类
models.AutoModelForMaskedLM
使用from_pretrained
函数实例化预训练掩码语言模型的辅助类。所选模型类由模型配置中指定的类型决定。
类型: models
的静态类
models.AutoModelForQuestionAnswering
使用from_pretrained
函数实例化预训练问答模型的辅助类。所选模型类由模型配置中指定的类型决定。
类型: models
的静态类
models.AutoModelForVision2Seq
使用from_pretrained
函数实例化预训练视觉到序列模型的辅助类。所选模型类由模型配置中指定的类型决定。
类型: models
的静态类
models.AutoModelForImageClassification
辅助类,用于使用from_pretrained
函数实例化预训练图像分类模型。选择的模型类由模型配置中指定的类型确定。
类型: models
的静态类
models.AutoModelForImageSegmentation
辅助类,用于使用from_pretrained
函数实例化预训练图像分割模型。选择的模型类由模型配置中指定的类型确定。
类型: models
的静态类
models.AutoModelForSemanticSegmentation
辅助类,用于使用from_pretrained
函数实例化预训练图像分割模型。选择的模型类由模型配置中指定的类型确定。
类型: models
的静态类
models.AutoModelForObjectDetection
用于使用from_pretrained
函数实例化预训练目标检测模型的辅助类。所选择的模型类由模型配置中指定的类型确定。
类型: models
的静态类
models.AutoModelForMaskGeneration
用于使用from_pretrained
函数实例化预训练掩码生成模型的辅助类。所选择的模型类由模型配置中指定的类型确定。
类型: models
的静态类
models.Seq2SeqLMOutput
类型: models
的静态类
new Seq2SeqLMOutput(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.logits | 张量(Tensor) | 模型的输出符号。 |
output.past_key_values | 张量(Tensor) | 表示模型前一个状态的键值对的张量。 |
output.encoder_outputs | 张量(Tensor) | 序列到序列模型中编码器输出的结果。 |
[output.decoder_attentions] | 张量(Tensor) | 解码器注意力权重,在注意力softmax后使用,用于计算自注意力头中的加权平均值。 |
[output.cross_attentions] | 张量(Tensor) | 解码器交叉注意力层的注意力权重,在注意力softmax后使用,用于计算交叉注意力头中的加权平均值。 |
models.SequenceClassifierOutput
句子分类模型输出的基类。
类型: models
的静态类
new SequenceClassifierOutput(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.logits | 张量(Tensor) | 分类(如果config.num_labels==1则为回归)的得分数(在SoftMax之前)。 |
models.XVectorOutput
XVector模型输出的基类。
类型: models
的静态类
new XVectorOutput(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.logits | 张量(Tensor) | 在AMSoftmax之前,形状为 |
output.embeddings | 张量(Tensor) | 用于基于向量相似度的检索的语音嵌入,形状为 |
models.TokenClassifierOutput
基于标记分类模型输出的基本类。
类型: models
的静态类
new TokenClassifierOutput(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.logits | 张量(Tensor) | 分类得分(SoftMax之前的)。 |
models.MaskedLMOutput
基于掩码语言模型输出的基本类。
类型: models
的静态类
new MaskedLMOutput(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.logits | 张量(Tensor) | 语言建模头部预测得分(SoftMax之前的每个词汇得分)。 |
models.QuestionAnsweringModelOutput
问答模型输出基类。
类型: models
的静态类
new QuestionAnsweringModelOutput(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.start_logits | 张量(Tensor) | 跨度起始分数(SoftMax之前)。 |
output.end_logits | 张量(Tensor) | 跨度结束分数(SoftMax之前)。 |
models.CausalLMOutput
因果语言模型(或自回归)输出基类。
类型: models
的静态类
new CausalLMOutput(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.logits | 张量(Tensor) | 语言模型头部的预测分数(softmax之前的每个词汇分数)。 |
models.CausalLMOutputWithPast
因果语言模型(或自回归)输出基类。
类型: models
的静态类
new CausalLMOutputWithPast(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.logits | 张量(Tensor) | 语言模型头部的预测分数(softmax之前的每个词汇分数)。 |
output.past_key_values | 张量(Tensor) | 包含预计算的隐藏状态(self-attention 块中的键和值),可用于(参见 |
models.ImageMattingOutput
类型: models
的静态类
new ImageMattingOutput(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.alphas | 张量(Tensor) | 估计的 alpha 值,形状为 |
models.VitsModelOutput
描述VITS模型的输出。
类型: models
的静态类
new VitsModelOutput(output)
参数 | 类型 | 说明 |
---|---|---|
output | 对象 | 模型的输出。 |
output.waveform | 张量(Tensor) | 模型预测出的最终音频波形,形状为 |
output.spectrogram | 张量(Tensor) | 在流动模型输出处的log-mel语谱图。此语谱图传递给Hi-Fi GAN解码器模型以获得最终的音频波形。 |
models~InferenceSession : <code> * </code>
类型:models
的内联类型
models~TypedArray : <code> * </code>
类型:models
的内联类型
models~DecoderOutput ⇒ <code> Promise. < (Array < Array < number > > |EncoderDecoderOutput|DecoderOutput) > </code>
根据给定的输入和生成配置以及模型生成文本。
类型:models
的内联类型
返回: Promise.<(Array<Array<number>>|EncoderDecoderOutput|DecoderOutput)>
- 由生成的输出序列数组,每个序列是一个包含标记ID的数组。
抛出异常:
Error
如果输入数组为空,则抛出错误。
参数 | 类型 | 默认 | 说明 |
---|---|---|---|
inputs | Tensor | Array | TypedArray | 一个包含输入标记ID的数组。 | |
generation_config | Object | GenerationConfig | null | 要使用的生成配置。如果为null,则使用默认配置。 | |
logits_processor | Object | null | 一个可选的logits处理器使用。如果为null,则创建一个新的LogitsProcessorList实例。 | |
options | 对象 | options | |
[options.inputs_attention_mask] | 对象 |
| 一个可选的输入注意力掩码。 |
models~WhisperGenerationConfig : <code> 对象 </code>
类型:models
的内联类型
扩展: GenerationConfig
属性
名称 | 类型 | 默认 | 说明 |
---|---|---|---|
[return_timestamps] | 布尔值 |
| 是否在文本中返回时间戳。这启用了 |
[return_token_timestamps] | 布尔值 |
| 是否在文本中返回标记级时间戳。这可以使用或不需要 |
[num_frames] | 数字 |
| 此块中可用的音频帧数量。这仅用于生成单词级时间戳。 |
models~SamModelInputs : <code> 对象 </code>
包含模型输入的对象。
类型:models
的内联类型
属性
名称 | 类型 | 说明 |
---|---|---|
pixel_values | 张量(Tensor) | 像素值作为形状为 |
input_points | 张量(Tensor) | 输入 2D 空间点,形状为 |
[input_labels] | 张量(Tensor) | 点的输入标签,形状为
|
[image_embeddings] | 张量(Tensor) | mask 解码器使用的图像嵌入。 |
[image_positional_embeddings] | 张量(Tensor) | mask 解码器使用的图像位置嵌入。 |
models~SpeechOutput : <code> 对象 </code>
类型:models
的内联类型
属性
名称 | 类型 | 说明 |
---|---|---|
[spectrogram] | 张量(Tensor) | 预测的对数梅尔频谱图,形状为 |
[waveform] | 张量(Tensor) | 预测的波形,形状为 |
[cross_attentions] | 张量(Tensor) | 解码器的交叉注意力层的输出,形状为 |
< > GitHub 更新