Transformers.js 文档

模型

Hugging Face's logo
加入Hugging Face社区

并获取增强文档体验

开始使用

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!'

models.PreTrainedModel

为预训练模型提供模型配置和ONNX会话的基类。

类型: models 的静态类


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*

包含生成参数的GenerationConfig对象。


preTrainedModel.groupBeams(beams) ⇒ <code>Array</code>

按ID分组一串beam对象。

类型: PreTrainedModel 的实例方法
返回值: Array - 一个二维数组,内部数组包含具有相同ID的beam对象。

参数类型说明
beamsArray

要分组的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字符串

预训练模型的名称或路径。可以是以下任一项:

  • 字符串,存储在huggingface.co的模型库中的预训练模型的model id。有效的模型id位于根级别,如bert-base-uncased,或者在用户或组织名称下命名空间,如dbmdz/bert-base-german-cased
  • 包含模型权重的目录的路径,例如,./my_model_directory/
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 logitsspan 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起始logitsspan结束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 logitsspan 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_configGenerationConfig

生成配置。


一个抽象类,用于处理权重初始化以及下载和加载预训练模型的简单接口。

类型: models 的静态类


一个LONGT5模型,输出原始的隐藏状态,而没有在顶部添加任何特定的头。

类型: models 的静态类


在顶部长T5模型上添加了语言建模头。

类型: models 的静态类


创建新的LongT5ForConditionalGeneration类的实例。

参数类型说明
config对象

模型配置。

session任意类型

模型的会话。

decoder_merged_session任意类型

解码器的session。

generation_configGenerationConfig

生成配置。


models.MT5ForConditionalGeneration

代表基于MT5架构的残留序列到序列模型的类。

类型: models 的静态类


new MT5ForConditionalGeneration(config, session, decoder_merged_session, generation_config)

创建了MT5ForConditionalGeneration类的新实例。

参数类型说明
config任意类型

模型配置。

session任意类型

包含编码器权重的ONNX会话。

decoder_merged_session任意类型

包含合并解码器权重的ONNX会话。

generation_configGenerationConfig

生成配置。


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_configGenerationConfig

生成配置。


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_configGenerationConfig

生成配置。


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_configWhisperGenerationConfig

生成过程的配置对象。

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_attentionsArray.<Array<Array<Tensor>>>

模型输出的交叉注意力。

generate_outputs.decoder_attentionsArray.<Array<Array<Tensor>>>

模型输出的解码注意力。

generate_outputs.sequencesArray.<Array<number>>

模型输出的序列。

alignment_headsArray.<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_configGenerationConfig

生成配置。


models.GPT2LMHeadModel

GPT-2 基础模型之上的语言模型头。此模型适用于文本生成任务。

类型: models 的静态类


models.GPTNeoPreTrainedModel

类型: models 的静态类


new GPTNeoPreTrainedModel(config, session, generation_config)

创建一个新的GPTNeoPreTrainedModel实例。

参数类型说明
config对象

模型的配置。

session任意类型

包含模型权重的 ONNX 会话。

generation_configGenerationConfig

生成配置。


models.GPTNeoXPreTrainedModel

类型: models 的静态类


new GPTNeoXPreTrainedModel(config, session, generation_config)

创建一个新的GPTNeoXPreTrainedModel实例。

参数类型说明
config对象

模型的配置。

session任意类型

包含模型权重的 ONNX 会话。

generation_configGenerationConfig

生成配置。


models.GPTJPreTrainedModel

类型: models 的静态类


new GPTJPreTrainedModel(config, session, generation_config)

创建一个 GPTJPreTrainedModel 类的新实例。

参数类型说明
config对象

模型的配置。

session任意类型

包含模型权重的 ONNX 会话。

generation_configGenerationConfig

生成配置。


models.GPTBigCodePreTrainedModel

类型: models 的静态类


new GPTBigCodePreTrainedModel(config, session, generation_config)

创建一个 GPTBigCodePreTrainedModel 类的新实例。

参数类型说明
config对象

模型的配置。

session任意类型

包含模型权重的 ONNX 会话。

generation_configGenerationConfig

生成配置。


models.CodeGenPreTrainedModel

类型: models 的静态类


new CodeGenPreTrainedModel(config, session, generation_config)

创建一个新的 CodeGenPreTrainedModel 类实例。

参数类型说明
config对象

模型配置对象。

session对象

ONNX 会话对象。

generation_configGenerationConfig

生成配置。


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_configGenerationConfig

生成配置。


models.LlamaModel

LLaMA模型直接输出原始隐藏状态,未加上任何特定头。

类型: models 的静态类


models.Qwen2PreTrainedModel

Qwen2模型直接输出原始隐藏状态,未加上任何特定头。

类型: models 的静态类


创建新的 Qwen2PreTrainedModel 对象(config, session, generation_config)

创建 Qwen2PreTrainedModel 类的新实例。

参数类型说明
config对象

模型配置对象。

session对象

ONNX 会话对象。

generation_configGenerationConfig

生成配置。


models.Qwen2Model

Qwen2模型直接输出原始隐藏状态,未加上任何特定头。

类型: models 的静态类


models.PhiPreTrainedModel

类型: models 的静态类


创建新的 PhiPreTrainedModel 对象(config, session, generation_config)

创建 PhiPreTrainedModel 类的新实例。

参数类型说明
config对象

模型配置对象。

session对象

ONNX 会话对象。

generation_configGenerationConfig

生成配置。


models.PhiModel

输出原始隐藏状态而不带有具体头部的裸Phi模型。

类型: models 的静态类


models.BloomPreTrainedModel

顶部带有语言模型头部的Bloom模型transformer。

类型: models 的静态类


new BloomPreTrainedModel(config, session, generation_config)

创建一个新的BloomPreTrainedModel类实例。

参数类型说明
config对象

模型的配置。

session任意类型

包含模型权重的 ONNX 会话。

generation_configGenerationConfig

生成配置。


models.BloomModel

输出原始隐藏状态而不带有具体头部的裸Bloom模型transformer。

类型: models 的静态类


models.BloomForCausalLM

顶部带有语言模型头部的Bloom模型transformer。

类型: models 的静态类


models.MptPreTrainedModel

类型: models 的静态类


new MptPreTrainedModel(config, session, generation_config)

创建一个MptPreTrainedModel类的实例。

参数类型说明
config对象

模型配置对象。

session对象

ONNX 会话对象。

generation_configGenerationConfig

生成配置。


models.MptModel

一个裸露的Mpt模型变压器,输出原始隐藏状态,上面没有任何特定的头部。

类型: models 的静态类


models.MptForCausalLM

顶部带有语言建模头(具有输入嵌入权重关联的线性层)的MPT模型transformer。

类型: models 的静态类


models.OPTPreTrainedModel

类型: models 的静态类


new OPTPreTrainedModel(config, session, generation_config)

创建一个OPTPreTrainedModel类的新实例。

参数类型说明
config对象

模型配置对象。

session对象

ONNX 会话对象。

generation_configGenerationConfig

生成配置。


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 的静态类


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)

使用 SamProcessor 获取的像素值。


有关 Promise.<Object> 和其使用的详细信息,请参阅 这里

类型SamModel 的实例方法
返回值Promise.<Object> - 模型的输出。

参数类型说明
model_inputsSamModelInputs

包含模型输入的对象。


有关 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_configGenerationConfig

生成配置。


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]对象

将梅尔频谱转换为语音波形的声码器。如果为 null,则输出是梅尔频谱。

[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_configGenerationConfig

生成配置。


models.TrOCRForCausalLM

具有语言建模头的 TrOCR 解码器。

类型: models 的静态类


models.MistralPreTrainedModel

无特定头输出的原始隐藏状态的裸Mistral模型。

类型: models 的静态类


new MistralPreTrainedModel(配置, 会话, 生成配置)

创建一个新的 MistralPreTrainedModel 类实例。

参数类型说明
config对象

模型的配置。

session任意类型

包含模型权重的 ONNX 会话。

generation_configGenerationConfig

生成配置。


models.Starcoder2PreTrainedModel

裸星Coder2模型输出原始隐藏状态,顶部不带任何特定头部。

类型: models 的静态类


new Starcoder2PreTrainedModel(配置, 会话, 生成配置)

创建一个新的 Starcoder2PreTrainedModel 类实例。

参数类型说明
config对象

模型的配置。

session任意类型

包含模型权重的 ONNX 会话。

generation_configGenerationConfig

生成配置。


models.FalconPreTrainedModel

裸Falcon模型输出原始隐藏状态,顶部不带任何特定头部。

类型: models 的静态类


new FalconPreTrainedModel(config, session, generation_config)

创建一个新的 FalconPreTrainedModel 类实例。

参数类型说明
config对象

模型的配置。

session任意类型

包含模型权重的 ONNX 会话。

generation_configGenerationConfig

生成配置。


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_configGenerationConfig

生成配置。


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.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之前,形状为(batch_size, config.xvector_output_dim)的分类隐藏状态。

output.embeddings张量(Tensor)

用于基于向量相似度的检索的语音嵌入,形状为(batch_size, config.xvector_output_dim)


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 块中的键和值),可用于(参见 past_key_values 输入)加快序列解码。


models.ImageMattingOutput

类型: models 的静态类


new ImageMattingOutput(output)

参数类型说明
output对象

模型的输出。

output.alphas张量(Tensor)

估计的 alpha 值,形状为 (batch_size, num_channels, height, width)


models.VitsModelOutput

描述VITS模型的输出。

类型: models 的静态类


new VitsModelOutput(output)

参数类型说明
output对象

模型的输出。

output.waveform张量(Tensor)

模型预测出的最终音频波形,形状为(batch_size, sequence_length)

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 如果输入数组为空,则抛出错误。
参数类型默认说明
inputsTensor | Array | TypedArray

一个包含输入标记ID的数组。

generation_configObject | GenerationConfig | null

要使用的生成配置。如果为null,则使用默认配置。

logits_processorObject | null

一个可选的logits处理器使用。如果为null,则创建一个新的LogitsProcessorList实例。

options对象

options

[options.inputs_attention_mask]对象

一个可选的输入注意力掩码。


models~WhisperGenerationConfig : <code> 对象 </code>

类型models的内联类型
扩展: GenerationConfig
属性

名称类型默认说明
[return_timestamps]布尔值

是否在文本中返回时间戳。这启用了WhisperTimestampsLogitsProcessor

[return_token_timestamps]布尔值

是否在文本中返回标记级时间戳。这可以使用或不需要return_timestamps选项。要获取单词级时间戳,请使用标记器将标记分组到单词中。

[num_frames]数字

此块中可用的音频帧数量。这仅用于生成单词级时间戳。


models~SamModelInputs : <code> 对象 </code>

包含模型输入的对象。

类型models的内联类型
属性

名称类型说明
pixel_values张量(Tensor)

像素值作为形状为 (batch_size, num_channels, height, width) 的 Tensor。这些可以使用 SamProcessor 获取。

input_points张量(Tensor)

输入 2D 空间点,形状为 (batch_size, num_points, 2)。该点由提示编码器用于编码提示。

[input_labels]张量(Tensor)

点的输入标签,形状为 (batch_size, point_batch_size, num_points) 的 Tensor。该点由提示编码器用于编码提示。有 4 种标签类型

  • 1:点包含感兴趣的对象
  • 0:点不包含感兴趣的对象
  • -1:点对应背景
  • -10:点是一个填充点,因此应由提示编码器忽略
[image_embeddings]张量(Tensor)

mask 解码器使用的图像嵌入。

[image_positional_embeddings]张量(Tensor)

mask 解码器使用的图像位置嵌入。


models~SpeechOutput : <code> 对象 </code>

类型models的内联类型
属性

名称类型说明
[spectrogram]张量(Tensor)

预测的对数梅尔频谱图,形状为 (output_sequence_length, config.num_mel_bins)。当未提供 vocoder 时返回。

[waveform]张量(Tensor)

预测的波形,形状为 (num_frames,)。当提供 vocoder 时返回。

[cross_attentions]张量(Tensor)

解码器的交叉注意力层的输出,形状为 (config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length)。当 output_cross_attentionstrue 时返回。


< > GitHub 更新