Hugging Face's logo

Transformers.js 文档

模型

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

models

Transformers.js 中所有可用模型的定义。

示例： 加载并运行 AutoModel。

import { AutoModel, AutoTokenizer } from '@huggingface/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 '@huggingface/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, sessions, configs)

创建 PreTrainedModel 类的新实例。

参数类型描述
config*

模型配置。
sessionsRecord.<string, any>

模型的推理会话。
configsRecord.<string, Object>

附加配置文件（例如，generation_config.json）。

preTrainedModel.custom_config : <code> * </code>

类型：PreTrainedModel 的实例属性

preTrainedModel.generation_config ⇒ <code> GenerationConfig </code> | <code> null </code>

获取模型的生成配置（如果存在）。

类型：PreTrainedModel 的实例属性
返回：GenerationConfig | null - 模型的生成配置（如果存在），否则为 null。

preTrainedModel.dispose() ⇒ <code> Promise. < Array < unknown > > </code>

释放推理期间创建的所有 ONNX 会话。

类型：PreTrainedModel 的实例方法
返回：Promise.<Array<unknown>> - Promise 数组，每个 Promise 对应一个正在释放的 ONNX 会话。
待办事项

preTrainedModel._call(model_inputs) ⇒ <code> Promise. < Object > </code>

使用提供的输入运行模型

类型：PreTrainedModel 的实例方法
返回：Promise.<Object> - 包含输出张量的对象

参数类型描述
model_inputsObject

包含输入张量的对象

preTrainedModel.forward(model_inputs) ⇒ <code> Promise. < Object > </code>

预训练模型的前向方法。如果子类未重写，则将根据模型类型选择正确的前向方法。

类型：PreTrainedModel 的实例方法
返回：Promise.<Object> - 来自模型的输出数据，格式在 ONNX 模型中指定。
抛出:

  • Error 必须在子类中实现此方法。
参数类型描述
model_inputsObject

模型的输入数据，格式在 ONNX 模型中指定。

preTrainedModel._get_logits_warper(generation_config) ⇒ <code> LogitsProcessorList </code>

此函数返回一个 [LogitsProcessorList] 列表对象，其中包含用于多项式采样的所有相关 [LogitsWarper] 实例。

类型：PreTrainedModel 的实例方法
返回：LogitsProcessorList - generation_config

参数类型描述
generation_configGenerationConfig

生成配置。

preTrainedModel._prepare_generation_config(generation_config, kwargs) ⇒ <code> GenerationConfig </code>

此函数将多个生成配置合并在一起，形成模型用于文本生成的最终生成配置。它首先创建一个空的 GenerationConfig 对象，然后将模型自身的 generation_config 属性应用于它。最后，如果参数中传入了 generation_config 对象，它将使用传入的配置对象的相应属性覆盖最终配置中的属性。

类型：PreTrainedModel 的实例方法
返回：GenerationConfig - 模型用于文本生成的最终生成配置对象。

参数类型描述
generation_configGenerationConfig | null

包含生成参数的 GenerationConfig 对象。
kwargsObject

要在 generation_config 对象中使用的参数之外使用的其他生成参数。

preTrainedModel._get_stopping_criteria(generation_config, [stopping_criteria])

类型：PreTrainedModel 的实例方法

参数类型默认
generation_configGenerationConfig
[stopping_criteria]StoppingCriteriaList

preTrainedModel._validate_model_class()

确认模型类与生成兼容。 如果不兼容，则引发异常，指向要使用的正确类。

类型：PreTrainedModel 的实例方法

preTrainedModel._update_model_kwargs_for_generation(inputs) ⇒ <code> Object </code>

类型：PreTrainedModel 的实例方法
返回值：Object - 下一次生成迭代的更新模型输入。

参数类型
inputsObject
inputs.generated_input_idsArray.<Array<bigint>>
inputs.outputsObject
inputs.model_inputsObject
inputs.is_encoder_decoderboolean

preTrainedModel._prepare_model_inputs(params) ⇒ <code> Object </code>

此函数提取模型特定的 inputs 用于生成。

类型：PreTrainedModel 的实例方法
返回值：Object - 模型特定的生成输入。

参数类型默认
paramsObject
[params.inputs]Tensor
[params.bos_token_id]number
[params.model_kwargs]Record.<string, (Tensor|Array<number>)>

preTrainedModel._prepare_decoder_input_ids_for_generation(param0)

为 encoder-decoder 模型准备用于生成的 decoder_input_ids

类型：PreTrainedModel 的实例方法

参数类型
param0*

preTrainedModel.generate(options) ⇒ <code> Promise. < (ModelOutput|Tensor) > </code>

为具有语言建模头的模型生成 token id 序列。

类型：PreTrainedModel 的实例方法
返回值：Promise.<(ModelOutput|Tensor)> - 模型的输出，可以包含生成的 token id、attention 和分数。

参数类型
options*

preTrainedModel.getPastKeyValues(decoderResults, pastKeyValues) ⇒ <code> Object </code>

从给定的解码器结果对象中返回包含过去键值的对象。

类型：PreTrainedModel 的实例方法
返回值：Object - 包含过去键值的对象。

参数类型描述
decoderResultsObject

解码器结果对象。
pastKeyValuesObject

之前的过去键值。

preTrainedModel.getAttentions(model_output) ⇒ <code> * </code>

从给定的模型输出对象中返回包含 attention 的对象。

类型：PreTrainedModel 的实例方法
返回值：* - 包含 attention 的对象。

参数类型描述
model_outputObject

模型的输出。

preTrainedModel.addPastKeyValues(decoderFeeds, pastKeyValues)

将过去的键值添加到解码器 feeds 对象。 如果 pastKeyValues 为 null，则为过去的键值创建新的张量。

类型：PreTrainedModel 的实例方法

参数类型描述
decoderFeedsObject

要添加过去键值的解码器 feeds 对象。
pastKeyValuesObject

包含过去键值的对象。

PreTrainedModel.from_pretrained(pretrained_model_name_or_path, options) ⇒ <code> Promise. < PreTrainedModel > </code>

从预训练模型实例化库的模型类之一。

要实例化的模型类是根据配置对象的 model_type 属性选择的（可以作为参数传递，也可以尽可能从 pretrained_model_name_or_path 加载）

类型：PreTrainedModel 的静态方法
返回值：Promise.<PreTrainedModel> - PreTrainedModel 类的新实例。

参数类型描述
pretrained_model_name_or_pathstring

预训练模型的名称或路径。 可以是

  • 一个字符串，托管在 huggingface.co 上的模型仓库内的预训练模型的模型 ID。 有效的模型 ID 可以位于根级别，例如 bert-base-uncased，或者在用户或组织名称下命名空间，例如 dbmdz/bert-base-german-cased。
  • 包含模型权重的目录的路径，例如，./my_model_directory/。
options*

用于加载模型的其他选项。

models.BaseModelOutput

模型输出的基类，具有潜在的隐藏状态和 attention。

类型：models 的静态类

new BaseModelOutput(output)

参数类型描述
outputObject

模型的输出。
output.last_hidden_stateTensor

模型最后一层的输出处的隐藏状态序列。
[output.hidden_states]Tensor

模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。
[output.attentions]Tensor

attention softmax 之后的 attention 权重，用于计算自注意力头中的加权平均值。

models.BertForMaskedLM

BertForMaskedLM 是一个类，表示用于掩码语言建模的 BERT 模型。

类型：models 的静态类

bertForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>

在新输入上调用模型。

类型：BertForMaskedLM 的实例方法
返回值：Promise.<MaskedLMOutput> - 一个对象，包含用于掩码语言建模的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.BertForSequenceClassification

BertForSequenceClassification 是一个类，表示用于序列分类的 BERT 模型。

类型：models 的静态类

bertForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

类型：BertForSequenceClassification 的实例方法
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.BertForTokenClassification

BertForTokenClassification 是一个类，表示用于 token 分类的 BERT 模型。

类型：models 的静态类

bertForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

类型：BertForTokenClassification 的实例方法
返回值：Promise.<TokenClassifierOutput> - 一个对象，包含用于 token 分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.BertForQuestionAnswering

BertForQuestionAnswering 是一个类，表示用于问答的 BERT 模型。

类型：models 的静态类

bertForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>

在新输入上调用模型。

类型：BertForQuestionAnswering 的实例方法
返回值：Promise.<QuestionAnsweringModelOutput> - 一个对象，包含用于问答的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.RoFormerModel

裸 RoFormer 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.RoFormerForMaskedLM

RoFormer 模型，顶部带有 language modeling head。

类型：models 的静态类

roFormerForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>

在新输入上调用模型。

类型：RoFormerForMaskedLM 的实例方法
返回值：Promise.<MaskedLMOutput> - 一个对象，包含用于掩码语言建模的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.RoFormerForSequenceClassification

RoFormer 模型 Transformer，顶部带有序列分类/回归 head（池化输出顶部的线性层）

类型：models 的静态类

roFormerForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

类型：RoFormerForSequenceClassification 的实例方法
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.RoFormerForTokenClassification

RoFormer 模型，顶部带有 token 分类 head（隐藏状态输出顶部的线性层），例如用于命名实体识别 (NER) 任务。

类型：models 的静态类

roFormerForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

类型：RoFormerForTokenClassification 的实例方法
返回值：Promise.<TokenClassifierOutput> - 一个对象，包含用于 token 分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.RoFormerForQuestionAnswering

RoFormer 模型，顶部带有 span 分类 head，用于抽取式问答任务，如 SQuAD（隐藏状态输出顶部的线性层，用于计算 span start logits 和 span end logits）。

类型：models 的静态类

roFormerForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>

在新输入上调用模型。

类型：RoFormerForQuestionAnswering 的实例方法
返回值：Promise.<QuestionAnsweringModelOutput> - 一个对象，包含用于问答的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.ConvBertModel

裸 ConvBERT 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.ConvBertForMaskedLM

ConvBERT 模型，顶部带有语言建模 head。

类型：models 的静态类

convBertForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>

在新输入上调用模型。

Kind: instance method of ConvBertForMaskedLM
返回值：Promise.<MaskedLMOutput> - 一个对象，包含用于掩码语言建模的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.ConvBertForSequenceClassification

ConvBERT 模型转换器，顶部带有一个序列分类/回归头（池化输出顶部的线性层）

类型：models 的静态类

convBertForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind: instance method of ConvBertForSequenceClassification
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.ConvBertForTokenClassification

ConvBERT 模型，顶部带有一个 token 分类头（隐藏状态输出顶部的线性层），例如用于命名实体识别 (NER) 任务。

类型：models 的静态类

convBertForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

Kind: instance method of ConvBertForTokenClassification
返回值：Promise.<TokenClassifierOutput> - 一个对象，包含用于 token 分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.ConvBertForQuestionAnswering

ConvBERT 模型，顶部带有一个跨度分类头，用于抽取式问答任务，如 SQuAD（隐藏状态输出顶部的线性层，用于计算 span start logits 和 span end logits）。

类型：models 的静态类

convBertForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>

在新输入上调用模型。

Kind: instance method of ConvBertForQuestionAnswering
返回值：Promise.<QuestionAnsweringModelOutput> - 一个对象，包含用于问答的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.ElectraModel

裸 ELECTRA 模型转换器，输出原始隐藏状态，顶部没有任何特定的头。与 BERT 模型相同，只是如果隐藏大小和嵌入大小不同，则在嵌入层和编码器之间使用额外的线性层。

类型：models 的静态类

models.ElectraForMaskedLM

Electra 模型，顶部带有一个语言建模头。

类型：models 的静态类

electraForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>

在新输入上调用模型。

Kind: instance method of ElectraForMaskedLM
返回值：Promise.<MaskedLMOutput> - 一个对象，包含用于掩码语言建模的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.ElectraForSequenceClassification

ELECTRA 模型转换器，顶部带有一个序列分类/回归头（池化输出顶部的线性层）

类型：models 的静态类

electraForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind: instance method of ElectraForSequenceClassification
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.ElectraForTokenClassification

Electra 模型，顶部带有一个 token 分类头。

类型：models 的静态类

electraForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

Kind: instance method of ElectraForTokenClassification
返回值：Promise.<TokenClassifierOutput> - 一个对象，包含用于 token 分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.ElectraForQuestionAnswering

LECTRA 模型，顶部带有一个跨度分类头，用于抽取式问答任务，如 SQuAD（隐藏状态输出顶部的线性层，用于计算 span start logits 和 span end logits）。

类型：models 的静态类

electraForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>

在新输入上调用模型。

Kind: instance method of ElectraForQuestionAnswering
返回值：Promise.<QuestionAnsweringModelOutput> - 一个对象，包含用于问答的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.CamembertModel

裸 CamemBERT 模型转换器，输出原始隐藏状态，顶部没有任何特定的头。

类型：models 的静态类

models.CamembertForMaskedLM

CamemBERT 模型，顶部带有 language modeling 头。

类型：models 的静态类

camembertForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>

在新输入上调用模型。

Kind: instance method of CamembertForMaskedLM
返回值：Promise.<MaskedLMOutput> - 一个对象，包含用于掩码语言建模的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.CamembertForSequenceClassification

CamemBERT 模型转换器，顶部带有一个序列分类/回归头（池化输出顶部的线性层），例如用于 GLUE 任务。

类型：models 的静态类

camembertForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind: instance method of CamembertForSequenceClassification
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.CamembertForTokenClassification

CamemBERT 模型，顶部带有一个 token 分类头（隐藏状态输出顶部的线性层），例如用于命名实体识别 (NER) 任务。

类型：models 的静态类

camembertForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

Kind: instance method of CamembertForTokenClassification
返回值：Promise.<TokenClassifierOutput> - 一个对象，包含用于 token 分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.CamembertForQuestionAnswering

CamemBERT 模型，顶部带有一个跨度分类头，用于抽取式问答任务

类型：models 的静态类

camembertForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>

在新输入上调用模型。

Kind: instance method of CamembertForQuestionAnswering
返回值：Promise.<QuestionAnsweringModelOutput> - 一个对象，包含用于问答的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.DebertaModel

裸 DeBERTa 模型转换器，输出原始隐藏状态，顶部没有任何特定的头。

类型：models 的静态类

models.DebertaForMaskedLM

DeBERTa 模型，顶部带有 language modeling 头。

类型：models 的静态类

debertaForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>

在新输入上调用模型。

Kind: instance method of DebertaForMaskedLM
返回值：Promise.<MaskedLMOutput> - 一个对象，包含用于掩码语言建模的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.DebertaForSequenceClassification

DeBERTa 模型转换器，顶部带有一个序列分类/回归头（池化输出顶部的线性层）

类型：models 的静态类

debertaForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind: instance method of DebertaForSequenceClassification
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.DebertaForTokenClassification

DeBERTa 模型，顶部带有一个 token 分类头（隐藏状态输出顶部的线性层），例如用于命名实体识别 (NER) 任务。

类型：models 的静态类

debertaForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

Kind: instance method of DebertaForTokenClassification
返回值：Promise.<TokenClassifierOutput> - 一个对象，包含用于 token 分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.DebertaForQuestionAnswering

DeBERTa 模型，顶部带有一个跨度分类头，用于抽取式问答任务，如 SQuAD（在隐藏状态输出之上添加线性层以计算 span start logits 和 span end logits）。

类型：models 的静态类

debertaForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>

在新输入上调用模型。

Kind: DebertaForQuestionAnswering 的实例方法
返回值：Promise.<QuestionAnsweringModelOutput> - 一个对象，包含用于问答的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.DebertaV2Model

裸 DeBERTa-V2 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.DebertaV2ForMaskedLM

DeBERTa-V2 模型，顶部带有一个 language modeling 头部。

类型：models 的静态类

debertaV2ForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>

在新输入上调用模型。

Kind: DebertaV2ForMaskedLM 的实例方法
返回值：Promise.<MaskedLMOutput> - 一个对象，包含用于掩码语言建模的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.DebertaV2ForSequenceClassification

DeBERTa-V2 模型 Transformer，顶部带有一个序列分类/回归头部（在池化输出之上添加一个线性层）。

类型：models 的静态类

debertaV2ForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind: DebertaV2ForSequenceClassification 的实例方法
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.DebertaV2ForTokenClassification

DeBERTa-V2 模型，顶部带有一个 token 分类头（在隐藏状态输出之上添加一个线性层），例如用于命名实体识别 (NER) 任务。

类型：models 的静态类

debertaV2ForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

Kind: DebertaV2ForTokenClassification 的实例方法
返回值：Promise.<TokenClassifierOutput> - 一个对象，包含用于 token 分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.DebertaV2ForQuestionAnswering

DeBERTa-V2 模型，顶部带有一个跨度分类头，用于抽取式问答任务，如 SQuAD（在隐藏状态输出之上添加线性层以计算 span start logits 和 span end logits）。

类型：models 的静态类

debertaV2ForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>

在新输入上调用模型。

Kind: DebertaV2ForQuestionAnswering 的实例方法
返回值：Promise.<QuestionAnsweringModelOutput> - 一个对象，包含用于问答的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.DistilBertForSequenceClassification

DistilBertForSequenceClassification 是一个类，表示用于序列分类的 DistilBERT 模型。

类型：models 的静态类

distilBertForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind: DistilBertForSequenceClassification 的实例方法
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.DistilBertForTokenClassification

DistilBertForTokenClassification 是一个类，表示用于 token 分类的 DistilBERT 模型。

类型：models 的静态类

distilBertForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

Kind: DistilBertForTokenClassification 的实例方法
返回值：Promise.<TokenClassifierOutput> - 一个对象，包含用于 token 分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.DistilBertForQuestionAnswering

DistilBertForQuestionAnswering 是一个类，表示用于问答的 DistilBERT 模型。

类型：models 的静态类

distilBertForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>

在新输入上调用模型。

Kind: DistilBertForQuestionAnswering 的实例方法
返回值：Promise.<QuestionAnsweringModelOutput> - 一个对象，包含用于问答的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.DistilBertForMaskedLM

DistilBertForMaskedLM 是一个类，表示用于掩码任务的 DistilBERT 模型。

类型：models 的静态类

distilBertForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>

在新输入上调用模型。

Kind: DistilBertForMaskedLM 的实例方法
Returns: Promise.<MaskedLMOutput> - 返回的对象

参数类型描述
model_inputsObject

模型的输入。

models.EsmModel

裸 ESM 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.EsmForMaskedLM

ESM 模型，顶部带有一个 language modeling 头部。

类型：models 的静态类

esmForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>

在新输入上调用模型。

Kind: EsmForMaskedLM 的实例方法
返回值：Promise.<MaskedLMOutput> - 一个对象，包含用于掩码语言建模的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.EsmForSequenceClassification

ESM 模型 Transformer，顶部带有一个序列分类/回归头部（在池化输出之上添加一个线性层）。

类型：models 的静态类

esmForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind: EsmForSequenceClassification 的实例方法
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.EsmForTokenClassification

ESM 模型，顶部带有一个 token 分类头（在隐藏状态输出之上添加一个线性层），例如用于命名实体识别 (NER) 任务。

类型：models 的静态类

esmForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

Kind: EsmForTokenClassification 的实例方法
返回值：Promise.<TokenClassifierOutput> - 一个对象，包含用于 token 分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.MobileBertForMaskedLM

MobileBertForMaskedLM 是一个类，表示用于掩码任务的 MobileBERT 模型。

类型：models 的静态类

mobileBertForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>

在新输入上调用模型。

Kind: MobileBertForMaskedLM 的实例方法
Returns: Promise.<MaskedLMOutput> - 返回的对象

参数类型描述
model_inputsObject

模型的输入。

models.MobileBertForSequenceClassification

MobileBert 模型 Transformer，顶部带有一个序列分类/回归头部（在池化输出之上添加一个线性层）。

类型：models 的静态类

mobileBertForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind: MobileBertForSequenceClassification 的实例方法
Returns: Promise.<SequenceClassifierOutput> - 返回的对象

参数类型描述
model_inputsObject

模型的输入。

models.MobileBertForQuestionAnswering

MobileBert 模型，顶部带有一个跨度分类头，用于抽取式问答任务。

类型：models 的静态类

mobileBertForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>

在新输入上调用模型。

Kind: MobileBertForQuestionAnswering 的实例方法
Returns: Promise.<QuestionAnsweringModelOutput> - 返回的对象

参数类型描述
model_inputsObject

模型的输入。

models.MPNetModel

裸 MPNet 模型转换器，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.MPNetForMaskedLM

MPNetForMaskedLM 是一个类，表示用于掩码语言建模的 MPNet 模型。

类型：models 的静态类

mpNetForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>

在新输入上调用模型。

Kind: MPNetForMaskedLM 的实例方法
返回值：Promise.<MaskedLMOutput> - 一个对象，包含用于掩码语言建模的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.MPNetForSequenceClassification

MPNetForSequenceClassification 是一个类，表示用于序列分类的 MPNet 模型。

类型：models 的静态类

mpNetForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind: MPNetForSequenceClassification 的实例方法
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.MPNetForTokenClassification

MPNetForTokenClassification 是一个类，表示用于token分类的 MPNet 模型。

类型：models 的静态类

mpNetForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

Kind: MPNetForTokenClassification 的实例方法
返回值：Promise.<TokenClassifierOutput> - 一个对象，包含用于 token 分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.MPNetForQuestionAnswering

MPNetForQuestionAnswering 是一个类，表示用于问题解答的 MPNet 模型。

类型：models 的静态类

mpNetForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>

在新输入上调用模型。

Kind: MPNetForQuestionAnswering 的实例方法
返回值：Promise.<QuestionAnsweringModelOutput> - 一个对象，包含用于问答的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.T5ForConditionalGeneration

T5Model 是一个类，表示用于条件生成的 T5 模型。

类型：models 的静态类

models.LongT5PreTrainedModel

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

类型：models 的静态类

models.LongT5Model

裸 LONGT5 模型转换器，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.LongT5ForConditionalGeneration

LONGT5 模型，顶部带有语言建模头。

类型：models 的静态类

models.MT5ForConditionalGeneration

一个类，表示基于 MT5 架构的条件序列到序列模型。

类型：models 的静态类

models.BartModel

裸 BART 模型，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.BartForConditionalGeneration

BART 模型，带有语言建模头。可用于摘要。

类型：models 的静态类

models.BartForSequenceClassification

Bart 模型，顶部带有序列分类/头（池化输出顶部的线性层）

类型：models 的静态类

bartForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind: BartForSequenceClassification 的实例方法
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.MBartModel

裸 MBART 模型，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.MBartForConditionalGeneration

MBART 模型，带有语言建模头。微调预训练模型后，可用于摘要。

类型：models 的静态类

models.MBartForSequenceClassification

MBart 模型，顶部带有序列分类/头（池化输出顶部的线性层）。

类型：models 的静态类

mBartForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind: MBartForSequenceClassification 的实例方法
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.BlenderbotModel

裸 Blenderbot 模型，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.BlenderbotForConditionalGeneration

Blenderbot 模型，带有语言建模头。可用于摘要。

类型：models 的静态类

models.BlenderbotSmallModel

裸 BlenderbotSmall 模型，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.BlenderbotSmallForConditionalGeneration

BlenderbotSmall 模型，带有语言建模头。可用于摘要。

类型：models 的静态类

models.RobertaForMaskedLM

RobertaForMaskedLM 类，用于对 Roberta 模型执行掩码语言建模。

类型：models 的静态类

robertaForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>

在新输入上调用模型。

Kind: RobertaForMaskedLM 的实例方法
Returns: Promise.<MaskedLMOutput> - 返回的对象

参数类型描述
model_inputsObject

模型的输入。

models.RobertaForSequenceClassification

RobertaForSequenceClassification 类，用于对 Roberta 模型执行序列分类。

类型：models 的静态类

robertaForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind: RobertaForSequenceClassification 的实例方法
Returns: Promise.<SequenceClassifierOutput> - 返回的对象

参数类型描述
model_inputsObject

模型的输入。

models.RobertaForTokenClassification

RobertaForTokenClassification 类，用于在 Roberta 模型上执行 token 分类。

类型：models 的静态类

robertaForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

Kind: RobertaForTokenClassification 的实例方法
返回值：Promise.<TokenClassifierOutput> - 一个对象，包含用于 token 分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.RobertaForQuestionAnswering

RobertaForQuestionAnswering 类，用于在 Roberta 模型上执行问题回答。

类型：models 的静态类

robertaForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>

在新输入上调用模型。

Kind: RobertaForQuestionAnswering 的实例方法
Returns: Promise.<QuestionAnsweringModelOutput> - 返回的对象

参数类型描述
model_inputsObject

模型的输入。

models.XLMPreTrainedModel

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

类型：models 的静态类

models.XLMModel

裸 XLM 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.XLMWithLMHeadModel

带有语言模型 head 的 XLM 模型 Transformer（线性层，其权重与输入 embeddings 绑定）。

类型：models 的静态类

xlmWithLMHeadModel._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>

在新输入上调用模型。

Kind: XLMWithLMHeadModel 的实例方法
Returns: Promise.<MaskedLMOutput> - 返回的对象

参数类型描述
model_inputsObject

模型的输入。

models.XLMForSequenceClassification

XLM 模型，顶部带有序列分类/回归 head（池化输出顶部的线性层）。

类型：models 的静态类

xlmForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind: XLMForSequenceClassification 的实例方法
Returns: Promise.<SequenceClassifierOutput> - 返回的对象

参数类型描述
model_inputsObject

模型的输入。

models.XLMForTokenClassification

XLM 模型，顶部带有 token 分类 head（隐藏状态输出顶部的线性层）。

类型：models 的静态类

xlmForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

Kind: XLMForTokenClassification 的实例方法
返回值：Promise.<TokenClassifierOutput> - 一个对象，包含用于 token 分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.XLMForQuestionAnswering

XLM 模型，顶部带有跨度分类 head，用于抽取式问题回答任务。

类型：models 的静态类

xlmForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>

在新输入上调用模型。

Kind: XLMForQuestionAnswering 的实例方法
Returns: Promise.<QuestionAnsweringModelOutput> - 返回的对象

参数类型描述
model_inputsObject

模型的输入。

models.XLMRobertaForMaskedLM

XLMRobertaForMaskedLM 类，用于在 XLMRoberta 模型上执行 masked language modeling。

类型：models 的静态类

xlmRobertaForMaskedLM._call(model_inputs) ⇒ <code> Promise. < MaskedLMOutput > </code>

在新输入上调用模型。

Kind: XLMRobertaForMaskedLM 的实例方法
Returns: Promise.<MaskedLMOutput> - 返回的对象

参数类型描述
model_inputsObject

模型的输入。

models.XLMRobertaForSequenceClassification

XLMRobertaForSequenceClassification 类，用于在 XLMRoberta 模型上执行序列分类。

类型：models 的静态类

xlmRobertaForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind: XLMRobertaForSequenceClassification 的实例方法
Returns: Promise.<SequenceClassifierOutput> - 返回的对象

参数类型描述
model_inputsObject

模型的输入。

models.XLMRobertaForTokenClassification

XLMRobertaForTokenClassification 类，用于在 XLMRoberta 模型上执行 token 分类。

类型：models 的静态类

xlmRobertaForTokenClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

Kind: XLMRobertaForTokenClassification 的实例方法
返回值：Promise.<TokenClassifierOutput> - 一个对象，包含用于 token 分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.XLMRobertaForQuestionAnswering

XLMRobertaForQuestionAnswering 类，用于在 XLMRoberta 模型上执行问题回答。

类型：models 的静态类

xlmRobertaForQuestionAnswering._call(model_inputs) ⇒ <code> Promise. < QuestionAnsweringModelOutput > </code>

在新输入上调用模型。

Kind: XLMRobertaForQuestionAnswering 的实例方法
Returns: Promise.<QuestionAnsweringModelOutput> - 返回的对象

参数类型描述
model_inputsObject

模型的输入。

models.ASTModel

裸 AST 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.ASTForAudioClassification

音频频谱图 Transformer 模型，顶部带有音频分类 head（池化输出顶部的线性层），例如用于 AudioSet、Speech Commands v2 等数据集。

类型：models 的静态类

models.WhisperModel

WhisperModel 类，用于训练不带语言模型 head 的 Whisper 模型。

类型：models 的静态类

models.WhisperForConditionalGeneration

WhisperForConditionalGeneration 类，用于从 Whisper 模型生成条件输出。

类型：models 的静态类

whisperForConditionalGeneration._retrieve_init_tokens(generation_config)

Kind: WhisperForConditionalGeneration 的实例方法

参数类型
generation_configWhisperGenerationConfig

whisperForConditionalGeneration.generate(options) ⇒ <code> Promise. < (ModelOutput|Tensor) > </code>

将 log-mel 输入特征转录或翻译成自回归生成的 token id 序列。

Kind: WhisperForConditionalGeneration 的实例方法
返回值：Promise.<(ModelOutput|Tensor)> - 模型的输出，可以包含生成的 token id、attention 和分数。

参数类型
options*

whisperForConditionalGeneration._extract_token_timestamps(generate_outputs, alignment_heads, [num_frames], [time_precision]) ⇒ <code> Tensor </code>

使用编码器-解码器交叉注意力机制和动态时间规整 (DTW) 计算 token 级别的 timestamps，以将每个输出 token 映射到输入音频中的位置。如果指定了 num_frames，则在应用 DTW 之前将裁剪编码器-解码器交叉注意力。

Kind: WhisperForConditionalGeneration 的实例方法
Returns: Tensor - 包含每个预测 token 的时间戳（秒）的 tensor

参数类型默认描述
generate_outputsObject

模型生成的输出
generate_outputs.cross_attentionsArray.<Array<Tensor>>

模型输出的交叉注意力
generate_outputs.sequencesTensor

模型输出的序列
alignment_headsArray.<Array<number>>

模型的对齐 head
[num_frames]number

输入音频中的帧数。
[time_precision]number0.02

时间戳的精度，单位为秒

models.VisionEncoderDecoderModel

基于 OpenAI 的 GPT 架构的视觉编码器-解码器模型，用于图像字幕和其他视觉任务

类型：models 的静态类

models.LlavaForConditionalGeneration

LLAVA 模型，由视觉骨干网络和语言模型组成。

类型：models 的静态类

models.CLIPModel

CLIP 文本和视觉模型，顶部带有投影层

示例： 使用 CLIPModel 执行零样本图像分类。

import { AutoTokenizer, AutoProcessor, CLIPModel, RawImage } from '@huggingface/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 的文本模型，顶部没有任何 head 或投影。

类型：models 的静态类

CLIPTextModel.from_pretrained() : <code> PreTrainedModel.from_pretrained </code>

类型：CLIPTextModel 的静态方法

models.CLIPTextModelWithProjection

CLIP 文本模型，顶部带有一个投影层（池化输出顶部的线性层）

示例： 使用 CLIPTextModelWithProjection 计算文本嵌入。

import { AutoTokenizer, CLIPTextModelWithProjection } from '@huggingface/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 的视觉模型，顶部没有任何 head 或投影。

类型：models 的静态类

CLIPVisionModel.from_pretrained() : <code> PreTrainedModel.from_pretrained </code>

类型：CLIPVisionModel 的静态方法

models.CLIPVisionModelWithProjection

CLIP 视觉模型，顶部带有一个投影层（池化输出顶部的线性层）

示例： 使用 CLIPVisionModelWithProjection 计算视觉嵌入。

import { AutoProcessor, CLIPVisionModelWithProjection, RawImage} from '@huggingface/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 '@huggingface/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 的文本模型，顶部没有任何 head 或投影。

示例： 使用 SiglipTextModel 计算文本嵌入。

import { AutoTokenizer, SiglipTextModel } from '@huggingface/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 的视觉模型，顶部没有任何 head 或投影。

示例： 使用 SiglipVisionModel 计算视觉嵌入。

import { AutoProcessor, SiglipVisionModel, RawImage} from '@huggingface/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 '@huggingface/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.GPT2LMHeadModel

GPT-2 语言模型 head 位于 GPT-2 基础模型的顶部。此模型适用于文本生成任务。

类型：models 的静态类

models.JAISModel

裸JAIS 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.JAISLMHeadModel

JAIS 模型 Transformer，顶部带有语言建模 head（权重与输入嵌入绑定的线性层）。

类型：models 的静态类

models.CodeGenModel

CodeGenModel 是一个类，表示没有语言模型 head 的代码生成模型。

类型：models 的静态类

models.CodeGenForCausalLM

CodeGenForCausalLM 是一个类，表示基于 GPT-2 架构的代码生成模型。它扩展了 CodeGenPreTrainedModel 类。

类型：models 的静态类

models.LlamaPreTrainedModel

裸 LLama 模型，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.LlamaModel

裸 LLaMA 模型，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.CoherePreTrainedModel

裸 Cohere 模型，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.GemmaPreTrainedModel

裸 Gemma 模型，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.GemmaModel

裸 Gemma 模型，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.Gemma2PreTrainedModel

裸 Gemma2 模型，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.Gemma2Model

裸 Gemma2 模型，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.Qwen2PreTrainedModel

裸 Qwen2 模型，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.Qwen2Model

裸 Qwen2 模型，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.PhiModel

裸 Phi 模型，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.Phi3Model

裸 Phi3 模型，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.BloomPreTrainedModel

带有语言建模 head 的 Bloom 模型 Transformer（线性层，权重与输入嵌入绑定）。

类型：models 的静态类

models.BloomModel

裸 Bloom 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.BloomForCausalLM

带有语言建模 head 的 Bloom 模型 Transformer（线性层，权重与输入嵌入绑定）。

类型：models 的静态类

models.MptModel

裸 Mpt 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.MptForCausalLM

带有语言建模 head 的 MPT 模型 Transformer（线性层，权重与输入嵌入绑定）。

类型：models 的静态类

models.OPTModel

裸 OPT 模型，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.OPTForCausalLM

带有语言建模 head 的 OPT 模型 Transformer（线性层，权重与输入嵌入绑定）。

类型：models 的静态类

models.VitMatteForImageMatting

ViTMatte 框架，利用任何视觉 backbone，例如用于 ADE20k、CityScapes。

示例： 使用 VitMatteForImageMatting 模型执行图像抠图。

import { AutoProcessor, VitMatteForImageMatting, RawImage } from '@huggingface/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, ... ]
// }

您可以如下可视化 alpha 遮罩

import { Tensor, cat } from '@huggingface/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)

参数类型描述
outputObject

模型的输出。
output.logitsTensor

所有查询的分类 logits（包括无对象）。
output.pred_boxesTensor

所有查询的归一化框坐标，表示为（center_x、center_y、width、height）。这些值在 [0, 1] 范围内归一化，相对于批次中每张单独图像的大小（忽略可能的填充）。

models.DetrSegmentationOutput

类型：models 的静态类

new DetrSegmentationOutput(output)

参数类型描述
outputObject

模型的输出。
output.logitsTensor

模型的输出 logits。
output.pred_boxesTensor

预测框。
output.pred_masksTensor

预测遮罩。

models.RTDetrObjectDetectionOutput

类型：models 的静态类

new RTDetrObjectDetectionOutput(output)

参数类型描述
outputObject

模型的输出。
output.logitsTensor

所有查询的分类 logits（包括无对象）。
output.pred_boxesTensor

所有查询的归一化框坐标，表示为（center_x、center_y、width、height）。这些值在 [0, 1] 范围内归一化，相对于批次中每张单独图像的大小（忽略可能的填充）。

models.TableTransformerModel

裸 Table Transformer 模型（由 backbone 和 encoder-decoder Transformer 组成），输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.TableTransformerForObjectDetection

Table Transformer 模型（由 backbone 和 encoder-decoder Transformer 组成），顶部带有对象检测 head，用于诸如 COCO 检测之类的任务。

类型：models 的静态类

tableTransformerForObjectDetection._call(model_inputs)

类型：TableTransformerForObjectDetection 的实例方法

参数类型
model_inputs任意类型

models.ResNetPreTrainedModel

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

类型：models 的静态类

models.ResNetModel

裸 ResNet 模型，输出原始特征，顶部没有任何特定的 head。

类型：models 的静态类

models.ResNetForImageClassification

带有图像分类 head 的 ResNet 模型（pooled 特征顶部的线性层），例如用于 ImageNet。

类型：models 的静态类

resNetForImageClassification._call(model_inputs)

类型：ResNetForImageClassification 的实例方法

参数类型
model_inputs任意类型

models.Swin2SRModel

裸 Swin2SR 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.Swin2SRForImageSuperResolution

带有 upsampler head 的 Swin2SR 模型 Transformer，用于图像超分辨率和修复。

示例： 超分辨率，使用 Xenova/swin2SR-classical-sr-x2-64。

import { AutoProcessor, Swin2SRForImageSuperResolution, RawImage } from '@huggingface/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 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.DPTForDepthEstimation

带有深度估计 head 的 DPT 模型（由 3 个卷积层组成），例如用于 KITTI、NYUv2。

示例： 深度估计，使用 Xenova/dpt-hybrid-midas。

import { DPTForDepthEstimation, AutoProcessor, RawImage, interpolate, max } from '@huggingface/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

带有深度估计 head 的 Depth Anything 模型（由 3 个卷积层组成），例如用于 KITTI、NYUv2。

类型：models 的静态类

models.GLPNModel

裸 GLPN 编码器 (Mix-Transformer)，输出原始隐藏状态，顶部没有任何特定的 head。

类型：models 的静态类

models.GLPNForDepthEstimation

GLPN 模型转换器，顶部带有一个轻量级的深度估计头，例如用于 KITTI、NYUv2。

示例： 深度估计，使用 Xenova/glpn-kitti。

import { GLPNForDepthEstimation, AutoProcessor, RawImage, interpolate, max } from '@huggingface/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 模型转换器，输出原始隐藏状态，顶部没有任何特定的头。

示例： 逐步文档解析。

import { AutoProcessor, AutoTokenizer, AutoModelForVision2Seq, RawImage } from '@huggingface/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 '@huggingface/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 模型转换器，输出原始隐藏状态，顶部没有任何特定的头。

类型：models 的静态类

models.Dinov2ForImageClassification

Dinov2 模型转换器，顶部带有一个图像分类头（[CLS] 令牌的最终隐藏状态顶部的线性层），例如用于 ImageNet。

类型：models 的静态类

dinov2ForImageClassification._call(model_inputs)

类型：Dinov2ForImageClassification 的实例方法

参数类型
model_inputs任意类型

models.YolosObjectDetectionOutput

类型：models 的静态类

new YolosObjectDetectionOutput(output)

参数类型描述
outputObject

模型的输出。
output.logitsTensor

所有查询的分类 logits（包括无对象）。
output.pred_boxesTensor

所有查询的归一化框坐标，表示为（center_x、center_y、width、height）。这些值在 [0, 1] 范围内归一化，相对于批次中每张单独图像的大小（忽略可能的填充）。

models.SamModel

Segment Anything Model (SAM)，用于生成分割掩码，给定输入图像和可选的 2D 位置和边界框。

示例： 使用 Xenova/sam-vit-base 执行掩码生成。

import { SamModel, AutoProcessor, RawImage } from '@huggingface/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 的静态类

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_inputsObject

包含模型输入的对象。
model_inputs.pixel_valuesTensor

使用 SamProcessor 获得的像素值。

samModel.forward(model_inputs) ⇒ <code> Promise. < Object > </code>

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

参数类型描述
model_inputsSamModelInputs

包含模型输入的对象。

samModel._call(model_inputs) ⇒ <code> Promise. < SamImageSegmentationOutput > </code>

使用提供的输入运行模型

类型：SamModel 的实例方法
返回：Promise.<SamImageSegmentationOutput> - 包含分割输出的对象

参数类型描述
model_inputsObject

模型输入

models.SamImageSegmentationOutput

Segment-Anything 模型输出的基类。

类型：models 的静态类

new SamImageSegmentationOutput(output)

参数类型描述
outputObject

模型的输出。
output.iou_scoresTensor

模型的输出 logits。
output.pred_masksTensor

预测框。

models.Wav2Vec2Model

裸 Wav2Vec2 模型转换器，输出原始隐藏状态，顶部没有任何特定的头。

示例： 加载并运行 Wav2Vec2Model 以进行特征提取。

import { AutoProcessor, AutoModel, read_audio } from '@huggingface/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> - 一个包含模型序列分类输出 logits 的对象。

参数类型描述
model_inputsObject

模型的输入。

models.PyAnnoteModel

裸 PyAnnote 模型转换器，输出原始隐藏状态，顶部没有任何特定的头。

类型：models 的静态类

models.PyAnnoteForAudioFrameClassification

PyAnnote 模型，顶部带有一个帧分类头，用于诸如说话人分离之类的任务。

示例： 加载并运行 PyAnnoteForAudioFrameClassification 以进行说话人分离。

import { AutoProcessor, AutoModelForAudioFrameClassification, read_audio } from '@huggingface/transformers';

// Load model and processor
const model_id = 'onnx-community/pyannote-segmentation-3.0';
const model = await AutoModelForAudioFrameClassification.from_pretrained(model_id);
const processor = await AutoProcessor.from_pretrained(model_id);

// Read and preprocess audio
const url = 'https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/mlk.wav';
const audio = await read_audio(url, processor.feature_extractor.config.sampling_rate);
const inputs = await processor(audio);

// Run model with inputs
const { logits } = await model(inputs);
// {
//   logits: Tensor {
//     dims: [ 1, 767, 7 ],  // [batch_size, num_frames, num_classes]
//     type: 'float32',
//     data: Float32Array(5369) [ ... ],
//     size: 5369
//   }
// }

const result = processor.post_process_speaker_diarization(logits, audio.length);
// [
//   [
//     { id: 0, start: 0, end: 1.0512535626298245, confidence: 0.8220156481664611 },
//     { id: 2, start: 1.0512535626298245, end: 2.3398869619825127, confidence: 0.9008811707860472 },
//     ...
//   ]
// ]

// Display result
console.table(result[0], ['start', 'end', 'id', 'confidence']);
// ┌─────────┬────────────────────┬────────────────────┬────┬─────────────────────┐
// │ (index) │ start              │ end                │ id │ confidence          │
// ├─────────┼────────────────────┼────────────────────┼────┼─────────────────────┤
// │ 0       │ 0                  │ 1.0512535626298245 │ 0  │ 0.8220156481664611  │
// │ 1       │ 1.0512535626298245 │ 2.3398869619825127 │ 2  │ 0.9008811707860472  │
// │ 2       │ 2.3398869619825127 │ 3.5946089560890773 │ 0  │ 0.7521651315796233  │
// │ 3       │ 3.5946089560890773 │ 4.578039708226655  │ 2  │ 0.8491978128022479  │
// │ 4       │ 4.578039708226655  │ 4.594995410849717  │ 0  │ 0.2935352600416393  │
// │ 5       │ 4.594995410849717  │ 6.121008646925269  │ 3  │ 0.6788051309866024  │
// │ 6       │ 6.121008646925269  │ 6.256654267909762  │ 0  │ 0.37125512393851134 │
// │ 7       │ 6.256654267909762  │ 8.630452635138397  │ 2  │ 0.7467035186353542  │
// │ 8       │ 8.630452635138397  │ 10.088643060721703 │ 0  │ 0.7689364814666032  │
// │ 9       │ 10.088643060721703 │ 12.58113134631177  │ 2  │ 0.9123324509131324  │
// │ 10      │ 12.58113134631177  │ 13.005023911888312 │ 0  │ 0.4828358177572041  │
// └─────────┴────────────────────┴────────────────────┴────┴─────────────────────┘

类型：models 的静态类

pyAnnoteForAudioFrameClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

类型：PyAnnoteForAudioFrameClassification 的实例方法
返回：Promise.<TokenClassifierOutput> - 一个包含模型序列分类输出 logits 的对象。

参数类型描述
model_inputsObject

模型的输入。

models.UniSpeechModel

裸 UniSpeech 模型转换器，输出原始隐藏状态，顶部没有任何特定的头。

类型：models 的静态类

models.UniSpeechForCTC

UniSpeech 模型，顶部带有一个 语言建模 头，用于 Connectionist Temporal Classification (CTC)。

类型：models 的静态类

uniSpeechForCTC._call(model_inputs)

类型：UniSpeechForCTC 的实例方法

参数类型描述
model_inputsObject
model_inputs.input_valuesTensor

输入原始语音波形的浮点值。
model_inputs.attention_maskTensor

用于避免在填充令牌索引上执行卷积和注意力的掩码。在 [0, 1] 中选择的掩码值

models.UniSpeechForSequenceClassification

UniSpeech 模型，顶部带有一个序列分类头（池化输出之上的线性层）。

类型：models 的静态类

uniSpeechForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

类型：UniSpeechForSequenceClassification 的实例方法
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.UniSpeechSatModel

不带任何特定头部且输出原始隐藏状态的裸 UniSpeechSat 模型 Transformer。

类型：models 的静态类

models.UniSpeechSatForCTC

带有用于 Connectionist Temporal Classification (CTC) 的 language modeling 头的 UniSpeechSat 模型。

类型：models 的静态类

uniSpeechSatForCTC._call(model_inputs)

Kind：UniSpeechSatForCTC 的实例方法

参数类型描述
model_inputsObject
model_inputs.input_valuesTensor

输入原始语音波形的浮点值。
model_inputs.attention_maskTensor

用于避免在填充令牌索引上执行卷积和注意力的掩码。在 [0, 1] 中选择的掩码值

models.UniSpeechSatForSequenceClassification

带有序列分类头的 UniSpeechSat 模型（池化输出上的线性层）。

类型：models 的静态类

uniSpeechSatForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind：UniSpeechSatForSequenceClassification 的实例方法
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.UniSpeechSatForAudioFrameClassification

带有用于诸如说话人日志等任务的帧分类头的 UniSpeechSat 模型。

类型：models 的静态类

uniSpeechSatForAudioFrameClassification._call(model_inputs) ⇒ <code> Promise. < TokenClassifierOutput > </code>

在新输入上调用模型。

Kind：UniSpeechSatForAudioFrameClassification 的实例方法
返回：Promise.<TokenClassifierOutput> - 一个包含模型序列分类输出 logits 的对象。

参数类型描述
model_inputsObject

模型的输入。

models.Wav2Vec2BertModel

不带任何特定头部且输出原始隐藏状态的裸 Wav2Vec2Bert 模型 Transformer。

类型：models 的静态类

models.Wav2Vec2BertForCTC

带有用于 Connectionist Temporal Classification (CTC) 的 language modeling 头的 Wav2Vec2Bert 模型。

类型：models 的静态类

wav2Vec2BertForCTC._call(model_inputs)

Kind：Wav2Vec2BertForCTC 的实例方法

参数类型描述
model_inputsObject
model_inputs.input_featuresTensor

输入梅尔频谱图的浮点值。
model_inputs.attention_maskTensor

用于避免在填充令牌索引上执行卷积和注意力的掩码。在 [0, 1] 中选择的掩码值

models.Wav2Vec2BertForSequenceClassification

带有序列分类头的 Wav2Vec2Bert 模型（池化输出上的线性层）。

类型：models 的静态类

wav2Vec2BertForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind：Wav2Vec2BertForSequenceClassification 的实例方法
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.HubertModel

不带任何特定头部且输出原始隐藏状态的裸 Hubert 模型 Transformer。

Example: 加载并运行 HubertModel 以进行特征提取。

import { AutoProcessor, AutoModel, read_audio } from '@huggingface/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

带有用于 Connectionist Temporal Classification (CTC) 的 language modeling 头的 Hubert 模型。

类型：models 的静态类

hubertForCTC._call(model_inputs)

Kind：HubertForCTC 的实例方法

参数类型描述
model_inputsObject
model_inputs.input_valuesTensor

输入原始语音波形的浮点值。
model_inputs.attention_maskTensor

用于避免在填充令牌索引上执行卷积和注意力的掩码。在 [0, 1] 中选择的掩码值

models.HubertForSequenceClassification

带有序列分类头的 Hubert 模型（池化输出上的线性层），用于诸如 SUPERB 关键词检测的任务。

类型：models 的静态类

hubertForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind：HubertForSequenceClassification 的实例方法
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.WavLMPreTrainedModel

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

类型：models 的静态类

models.WavLMModel

不带任何特定头部且输出原始隐藏状态的裸 WavLM 模型 Transformer。

Example: 加载并运行 WavLMModel 以进行特征提取。

import { AutoProcessor, AutoModel, read_audio } from '@huggingface/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

带有用于 Connectionist Temporal Classification (CTC) 的 language modeling 头的 WavLM 模型。

类型：models 的静态类

wavLMForCTC._call(model_inputs)

Kind：WavLMForCTC 的实例方法

参数类型描述
model_inputsObject
model_inputs.input_valuesTensor

输入原始语音波形的浮点值。
model_inputs.attention_maskTensor

用于避免在填充令牌索引上执行卷积和注意力的掩码。在 [0, 1] 中选择的掩码值

models.WavLMForSequenceClassification

带有序列分类头的 WavLM 模型（池化输出上的线性层）。

类型：models 的静态类

wavLMForSequenceClassification._call(model_inputs) ⇒ <code> Promise. < SequenceClassifierOutput > </code>

在新输入上调用模型。

Kind：WavLMForSequenceClassification 的实例方法
返回值：Promise.<SequenceClassifierOutput> - 一个对象，包含用于序列分类的模型输出 logits。

参数类型描述
model_inputsObject

模型的输入。

models.WavLMForXVector

带有用于诸如说话人验证等任务的 XVector 特征提取头的 WavLM 模型。

Example: 使用 WavLMForXVector 提取说话人嵌入。

import { AutoProcessor, AutoModel, read_audio } from '@huggingface/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>

在新输入上调用模型。

Kind：WavLMForXVector 的实例方法
Returns: Promise.<XVectorOutput> - 包含模型输出 logits 和说话人嵌入的对象。

参数类型描述
model_inputsObject

模型的输入。

models.WavLMForAudioFrameClassification

带有用于诸如说话人日志等任务的帧分类头的 WavLM 模型。

Example: 使用 WavLMForAudioFrameClassification 执行说话人日志。

import { AutoProcessor, AutoModelForAudioFrameClassification, read_audio } from '@huggingface/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>

在新输入上调用模型。

Kind：WavLMForAudioFrameClassification 的实例方法
返回：Promise.<TokenClassifierOutput> - 一个包含模型序列分类输出 logits 的对象。

参数类型描述
model_inputsObject

模型的输入。

models.SpeechT5PreTrainedModel

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

类型：models 的静态类

models.SpeechT5Model

不带任何特定前置或后置网络的裸 SpeechT5 编码器-解码器模型，输出原始隐藏状态。

类型：models 的静态类

models.SpeechT5ForSpeechToText

带有语音编码器和文本解码器的 SpeechT5 模型。

示例： 使用 SpeechT5ForSpeechToText 从文本生成语音。

import { AutoTokenizer, AutoProcessor, SpeechT5ForTextToSpeech, SpeechT5HifiGan, Tensor } from '@huggingface/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 full-precision versions as they are more accurate
const model = await SpeechT5ForTextToSpeech.from_pretrained('Xenova/speecht5_tts', { dtype: 'fp32' });
const vocoder = await SpeechT5HifiGan.from_pretrained('Xenova/speecht5_hifigan', { dtype: 'fp32' });

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

speechT5ForTextToSpeech.generate_speech(input_values, speaker_embeddings, options) ⇒ <code> Promise. < SpeechOutput > </code>

将输入令牌序列转换为 mel 频谱图序列，然后使用声码器将这些频谱图转换为语音波形。

类型：SpeechT5ForTextToSpeech 的实例方法
返回值：Promise.<SpeechOutput> - 一个 Promise，它解析为一个包含频谱图、波形和交叉注意力张量的对象。

参数类型默认描述
input_valuesTensor

词汇表中输入序列令牌的索引。
speaker_embeddingsTensor

包含说话人嵌入的张量。
optionsObject

用于生成语音的可选参数。
[options.threshold]number0.5

当预测的停止令牌概率超过此值时，生成的序列结束。
[options.minlenratio]number0.0

用于计算输出序列所需的最小长度。
[options.maxlenratio]number20.0

用于计算输出序列允许的最大长度。
[options.vocoder]Object

将 mel 频谱图转换为语音波形的声码器。如果为 null，则输出为 mel 频谱图。
[options.output_cross_attentions]booleanfalse

是否返回解码器交叉注意力层的注意力张量。

models.SpeechT5HifiGan

HiFi-GAN 声码器。

有关使用示例，请参见 SpeechT5ForSpeechToText。

类型：models 的静态类

models.TrOCRForCausalLM

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

类型：models 的静态类

models.MistralPreTrainedModel

裸 Mistral 模型，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.Starcoder2PreTrainedModel

裸 Starcoder2 模型，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.FalconPreTrainedModel

裸 Falcon 模型，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.ClapTextModelWithProjection

CLAP 文本模型，顶部带有一个投影层（池化输出顶部的线性层）。

示例： 使用 ClapTextModelWithProjection 计算文本嵌入。

import { AutoTokenizer, ClapTextModelWithProjection } from '@huggingface/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 '@huggingface/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 模型，用于文本到语音合成。

示例： 使用 VitsModel 从文本生成语音。

import { AutoTokenizer, VitsModel } from '@huggingface/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_inputsObject

模型的输入。

models.SegformerModel

裸 SegFormer 编码器 (Mix-Transformer)，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.SegformerForImageClassification

SegFormer 模型 Transformer，顶部带有一个图像分类头（最终隐藏状态顶部的线性层），例如用于 ImageNet。

类型：models 的静态类

models.SegformerForSemanticSegmentation

SegFormer 模型 Transformer，顶部带有 all-MLP 解码头，例如用于 ADE20k、CityScapes。

类型：models 的静态类

models.StableLmModel

裸 StableLm 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.StableLmForCausalLM

StableLm 模型，顶部带有 language modeling 头，用于因果语言建模（带历史记录）。

类型：models 的静态类

models.EfficientNetModel

裸 EfficientNet 模型，输出原始特征，顶部没有任何特定的头部。

类型：models 的静态类

models.EfficientNetForImageClassification

EfficientNet 模型，顶部带有一个图像分类头（池化特征顶部的线性层）。

类型：models 的静态类

efficientNetForImageClassification._call(model_inputs)

类型：EfficientNetForImageClassification 的实例方法

参数类型
model_inputs任意类型

models.MusicgenModel

裸 Musicgen 解码器模型，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.MusicgenForCausalLM

带有语言建模头的 MusicGen 解码器模型。

类型：models 的静态类

models.MusicgenForConditionalGeneration

复合 MusicGen 模型，带有文本编码器、音频编码器和 Musicgen 解码器，用于执行带有一个或两个文本和音频提示的音乐生成任务。

示例： 使用 Xenova/musicgen-small 从文本生成音乐。

import { AutoTokenizer, MusicgenForConditionalGeneration } from '@huggingface/transformers';

// Load tokenizer and model
const tokenizer = await AutoTokenizer.from_pretrained('Xenova/musicgen-small');
const model = await MusicgenForConditionalGeneration.from_pretrained(
  'Xenova/musicgen-small', { dtype: 'fp32' }
);

// Prepare text input
const prompt = '80s pop track with bassy drums and synth';
const inputs = tokenizer(prompt);

// Generate audio
const audio_values = await model.generate({
  ...inputs,
  max_new_tokens: 512,
  do_sample: true,
  guidance_scale: 3,
});

// (Optional) Write the output to a WAV file
import wavefile from 'wavefile';
import fs from 'fs';

const wav = new wavefile.WaveFile();
wav.fromScratch(1, model.config.audio_encoder.sampling_rate, '32f', audio_values.data);
fs.writeFileSync('musicgen_out.wav', wav.toBuffer());

类型：models 的静态类

musicgenForConditionalGeneration._apply_and_filter_by_delay_pattern_mask(outputs) ⇒ <code> Tensor </code>

将模式掩码应用于最终 ID，然后通过在单个步骤中过滤掉 pad 令牌 ID 来恢复模式延迟掩码。

类型：MusicgenForConditionalGeneration 的实例方法
返回值：Tensor - 经过滤的输出张量。

参数类型描述
outputsTensor

来自模型的输出张量。

musicgenForConditionalGeneration.generate(options) ⇒ <code> Promise. < (ModelOutput|Tensor) > </code>

为具有语言建模头的模型生成 token id 序列。

类型：MusicgenForConditionalGeneration 的实例方法
返回值：Promise.<(ModelOutput|Tensor)> - 模型的输出，可以包含生成的 token id、attention 和分数。

参数类型
options*

models.MobileNetV1Model

裸 MobileNetV1 模型，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.MobileNetV1ForImageClassification

MobileNetV1 模型，顶部带有一个图像分类头（池化特征顶部的线性层），例如用于 ImageNet。

类型：models 的静态类

mobileNetV1ForImageClassification._call(model_inputs)

类型：MobileNetV1ForImageClassification 的实例方法

参数类型
model_inputs任意类型

models.MobileNetV2Model

裸 MobileNetV2 模型，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.MobileNetV2ForImageClassification

MobileNetV2 模型，顶部带有一个图像分类头（池化特征顶部的线性层），例如用于 ImageNet。

类型：models 的静态类

mobileNetV2ForImageClassification._call(model_inputs)

类型：MobileNetV2ForImageClassification 的实例方法

参数类型
model_inputs任意类型

models.MobileNetV3Model

裸 MobileNetV3 模型，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.MobileNetV3ForImageClassification

MobileNetV3 模型，顶部带有一个图像分类头（池化特征顶部的线性层），例如用于 ImageNet。

类型：models 的静态类

mobileNetV3ForImageClassification._call(model_inputs)

类型：MobileNetV3ForImageClassification 的实例方法

参数类型
model_inputs任意类型

models.MobileNetV4Model

裸 MobileNetV4 模型，输出原始隐藏状态，顶部没有任何特定的头部。

类型：models 的静态类

models.MobileNetV4ForImageClassification

MobileNetV4 模型，顶部带有一个图像分类头（池化特征顶部的线性层），例如用于 ImageNet。

类型：models 的静态类

mobileNetV4ForImageClassification._call(model_inputs)

类型：MobileNetV4ForImageClassification 的实例方法

参数类型
model_inputs任意类型

models.DecisionTransformerModel

该模型基于 GPT2 架构构建，用于在离线 RL 设置中执行动作的自回归预测。有关更多详细信息，请参阅论文：https://arxiv.org/abs/2106.01345

类型：models 的静态类

models.PretrainedMixin

所有 AutoModels 的基类。包含 from_pretrained 函数，该函数用于实例化预训练模型。

类型：models 的静态类

pretrainedMixin.MODEL_CLASS_MAPPINGS : <code> * </code>

从模型类型到模型类的映射。

类型：PretrainedMixin 的实例属性

pretrainedMixin.BASE_IF_FAIL

如果映射中未找到模型类型，是否尝试实例化基类 (PretrainedModel)。

类型：PretrainedMixin 的实例属性

PretrainedMixin.from_pretrained() : <code> * </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 的静态类

辅助类，用于使用 from_pretrained 函数实例化预训练的通用图像分割模型。所选的模型类由模型配置中指定的类型确定。

辅助类，用于使用 from_pretrained 函数实例化预训练的通用图像分割模型。所选的模型类由模型配置中指定的类型确定。

类型：models 的静态类

models.AutoModelForObjectDetection

辅助类，用于使用 from_pretrained 函数实例化预训练的目标检测模型。所选的模型类由模型配置中指定的类型确定。

类型：models 的静态类

models.AutoModelForMaskGeneration

辅助类，用于使用 from_pretrained 函数实例化预训练的掩码生成模型。所选的模型类由模型配置中指定的类型确定。

类型：models 的静态类

models.Seq2SeqLMOutput

类型：models 的静态类

new Seq2SeqLMOutput(output)

参数类型描述
outputObject

模型的输出。
output.logitsTensor

模型的输出 logits。
output.past_key_valuesTensor

一个键/值对张量，表示模型的先前状态。
output.encoder_outputsTensor

序列到序列模型中编码器的输出。
[output.decoder_attentions]Tensor

解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
[output.cross_attentions]Tensor

解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

models.SequenceClassifierOutput

句子分类模型输出的基类。

类型：models 的静态类

new SequenceClassifierOutput(output)

参数类型描述
outputObject

模型的输出。
output.logitsTensor

分类（或回归，如果 config.num_labels==1）分数（在 SoftMax 之前）。

models.XVectorOutput

XVector 模型输出的基类。

类型：models 的静态类

new XVectorOutput(output)

参数类型描述
outputObject

模型的输出。
output.logitsTensor

AMSoftmax 之前的分类隐藏状态，形状为 (batch_size, config.xvector_output_dim)。
output.embeddingsTensor

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

models.TokenClassifierOutput

token 分类模型输出的基类。

类型：models 的静态类

new TokenClassifierOutput(output)

参数类型描述
outputObject

模型的输出。
output.logitsTensor

分类分数（在 SoftMax 之前）。

models.MaskedLMOutput

掩码语言模型输出的基类。

类型：models 的静态类

new MaskedLMOutput(output)

参数类型描述
outputObject

模型的输出。
output.logitsTensor

语言建模头的预测分数（每个词汇表 token 在 SoftMax 之前的分数）。

models.QuestionAnsweringModelOutput

问答模型输出的基类。

类型：models 的静态类

new QuestionAnsweringModelOutput(output)

参数类型描述
outputObject

模型的输出。
output.start_logitsTensor

跨度起始分数（在 SoftMax 之前）。
output.end_logitsTensor

跨度结束分数（在 SoftMax 之前）。

models.CausalLMOutput

因果语言模型（或自回归）输出的基类。

类型：models 的静态类

new CausalLMOutput(output)

参数类型描述
outputObject

模型的输出。
output.logitsTensor

语言建模头的预测分数（每个词汇表 token 在 softmax 之前的分数）。

models.CausalLMOutputWithPast

因果语言模型（或自回归）输出的基类。

类型：models 的静态类

new CausalLMOutputWithPast(output)

参数类型描述
outputObject

模型的输出。
output.logitsTensor

语言建模头的预测分数（每个词汇表 token 在 softmax 之前的分数）。
output.past_key_valuesTensor

包含预先计算的隐藏状态（自注意力块中的键和值），可以用于（参见 past_key_values 输入）加速顺序解码。

models.ImageMattingOutput

类型：models 的静态类

new ImageMattingOutput(output)

参数类型描述
outputObject

模型的输出。
output.alphasTensor

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

models.VitsModelOutput

描述 VITS 模型的输出。

类型：models 的静态类

new VitsModelOutput(output)

参数类型描述
outputObject

模型的输出。
output.waveformTensor

模型预测的最终音频波形，形状为 (batch_size, sequence_length)。
output.spectrogramTensor

在 flow 模型输出端预测的 log-mel 频谱图。此频谱图被传递到 Hi-Fi GAN 解码器模型以获得最终音频波形。

models~SamModelInputs : <code> Object </code>

包含模型输入的对象。

Kind：models 的内部类型定义
属性

名称类型描述
pixel_valuesTensor

像素值，作为形状为 (batch_size, num_channels, height, width) 的张量。这些可以使用 SamProcessor 获得。
[input_points]Tensor

输入 2D 空间点，形状为 (batch_size, num_points, 2)。这由 prompt 编码器用于编码 prompt。
[input_labels]Tensor

点的输入标签，作为形状为 (batch_size, point_batch_size, num_points) 的张量。这由 prompt 编码器用于编码 prompt。有 4 种类型的标签

  • 1：该点是包含感兴趣对象的点
  • 0：该点是不包含感兴趣对象的点
  • -1：该点对应于背景
  • -10：该点是填充点，因此应被 prompt 编码器忽略
[input_boxes]Tensor

输入边界框，形状为 (batch_size, num_boxes, 4)。
[image_embeddings]Tensor

掩码解码器使用的图像嵌入。
[image_positional_embeddings]Tensor

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

models~SpeechOutput : <code> Object </code>

Kind：models 的内部类型定义
属性

名称类型描述
[spectrogram]Tensor

预测的 log-mel 频谱图，形状为 (output_sequence_length, config.num_mel_bins)。当未提供 vocoder 时返回
[waveform]Tensor

预测的波形，形状为 (num_frames,)。当提供 vocoder 时返回。
[交叉注意力]Tensor

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

< > 在 GitHub 上更新

←流水线 分词器→