Definitions of all models available in Transformers.js.
Example: Load and run an 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,
// }
We also provide other AutoModel
s (listed below), which you can use in the same way as the Python library. For example:
Example: Load and run a 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!'
Callable
new PreTrainedModel(config, session)
.dispose()
⇒ Promise.<Array<unknown>>
._call(model_inputs)
⇒ Promise.<Object>
.forward(model_inputs)
⇒ Promise.<Object>
._get_generation_config(generation_config)
⇒ GenerationConfig
.groupBeams(beams)
⇒ Array
.getPastKeyValues(decoderResults, pastKeyValues)
⇒ Object
.getAttentions(decoderResults)
⇒ Object
.addPastKeyValues(decoderFeeds, pastKeyValues, [hasDecoder])
.from_pretrained(pretrained_model_name_or_path, options)
⇒ Promise.<PreTrainedModel>
BertPreTrainedModel
._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
BertPreTrainedModel
._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
BertPreTrainedModel
._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
BertPreTrainedModel
._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
DistilBertPreTrainedModel
._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
DistilBertPreTrainedModel
._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
DistilBertPreTrainedModel
._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
DistilBertPreTrainedModel
._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
MobileBertPreTrainedModel
._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
MobileBertPreTrainedModel
._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
MobileBertPreTrainedModel
._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
MPNetPreTrainedModel
MPNetPreTrainedModel
._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
MPNetPreTrainedModel
._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
MPNetPreTrainedModel
._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
MPNetPreTrainedModel
._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
T5PreTrainedModel
MT5PreTrainedModel
BartPretrainedModel
BartPretrainedModel
._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
RobertaPreTrainedModel
._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
RobertaPreTrainedModel
._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
RobertaPreTrainedModel
._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
RobertaPreTrainedModel
._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
XLMRobertaPreTrainedModel
._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
XLMRobertaPreTrainedModel
._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
XLMRobertaPreTrainedModel
._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
XLMRobertaPreTrainedModel
._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
WhisperPreTrainedModel
WhisperPreTrainedModel
PreTrainedModel
.from_pretrained()
: PreTrainedModel.from_pretrained
.from_pretrained()
: PreTrainedModel.from_pretrained
GPT2PreTrainedModel
CodeGenPreTrainedModel
CodeGenPreTrainedModel
new MarianMTModel(config, session, decoder_merged_session, generation_config)
.forward(model_inputs)
⇒ Promise.<Seq2SeqLMOutput>
new M2M100ForConditionalGeneration(config, session, decoder_merged_session, generation_config)
.forward(model_inputs)
⇒ Promise.<Seq2SeqLMOutput>
._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
.from_pretrained()
: PreTrainedModel.from_pretrained
~PretrainedOptions
: *
~TypedArray
: *
~DecoderOutput
⇒ Promise.<(Array<Array<number>>|EncoderDecoderOutput|DecoderOutput)>
~WhisperGenerationConfig
: Object
Callable
A base class for pre-trained models that provides the model configuration and an ONNX session.
Kind: static class of models
Extends: Callable
Callable
new PreTrainedModel(config, session)
.dispose()
⇒ Promise.<Array<unknown>>
._call(model_inputs)
⇒ Promise.<Object>
.forward(model_inputs)
⇒ Promise.<Object>
._get_generation_config(generation_config)
⇒ GenerationConfig
.groupBeams(beams)
⇒ Array
.getPastKeyValues(decoderResults, pastKeyValues)
⇒ Object
.getAttentions(decoderResults)
⇒ Object
.addPastKeyValues(decoderFeeds, pastKeyValues, [hasDecoder])
.from_pretrained(pretrained_model_name_or_path, options)
⇒ Promise.<PreTrainedModel>
new PreTrainedModel(config, session)
Creates a new instance of the PreTrainedModel
class.
Param | Type | Description |
---|---|---|
config | Object | The model configuration. |
session | any | session for the model. |
preTrainedModel.dispose()
⇒ Promise.<Array<unknown>>
Disposes of all the ONNX sessions that were created during inference.
Kind: instance method of PreTrainedModel
Returns: Promise.<Array<unknown>>
- An array of promises, one for each ONNX session that is being disposed.
Todo
preTrainedModel._call(model_inputs)
⇒ Promise.<Object>
Runs the model with the provided inputs
Kind: instance method of PreTrainedModel
Returns: Promise.<Object>
- Object containing output tensors
Param | Type | Description |
---|---|---|
model_inputs | Object | Object containing input tensors |
preTrainedModel.forward(model_inputs)
⇒ Promise.<Object>
Forward method for a pretrained model. If not overridden by a subclass, the correct forward method will be chosen based on the model type.
Kind: instance method of PreTrainedModel
Returns: Promise.<Object>
- The output data from the model in the format specified in the ONNX model.
Throws:
Error
This method must be implemented in subclasses.Param | Type | Description |
---|---|---|
model_inputs | Object | The input data to the model in the format specified in the ONNX model. |
preTrainedModel._get_generation_config(generation_config)
⇒ GenerationConfig
This function merges multiple generation configs together to form a final generation config to be used by the model for text generation.
It first creates an empty GenerationConfig
object, then it applies the model’s own generation_config
property to it. Finally, if a generation_config
object was passed in the arguments, it overwrites the corresponding properties in the final config with those of the passed config object.
Kind: instance method of PreTrainedModel
Returns: GenerationConfig
- The final generation config object to be used by the model for text generation.
Param | Type | Description |
---|---|---|
generation_config | GenerationConfig | A |
preTrainedModel.groupBeams(beams)
⇒ Array
Groups an array of beam objects by their ids.
Kind: instance method of PreTrainedModel
Returns: Array
- An array of arrays, where each inner array contains beam objects with the same id.
Param | Type | Description |
---|---|---|
beams | Array | The array of beam objects to group. |
preTrainedModel.getPastKeyValues(decoderResults, pastKeyValues)
⇒ Object
Returns an object containing past key values from the given decoder results object.
Kind: instance method of PreTrainedModel
Returns: Object
- An object containing past key values.
Param | Type | Description |
---|---|---|
decoderResults | Object | The decoder results object. |
pastKeyValues | Object | The previous past key values. |
preTrainedModel.getAttentions(decoderResults)
⇒ Object
Returns an object containing attentions from the given decoder results object.
Kind: instance method of PreTrainedModel
Returns: Object
- An object containing attentions.
Param | Type | Description |
---|---|---|
decoderResults | Object | The decoder results object. |
preTrainedModel.addPastKeyValues(decoderFeeds, pastKeyValues, [hasDecoder])
Adds past key values to the decoder feeds object. If pastKeyValues is null, creates new tensors for past key values.
Kind: instance method of PreTrainedModel
Param | Type | Default | Description |
---|---|---|---|
decoderFeeds | Object | The decoder feeds object to add past key values to. |
|
pastKeyValues | Object | An object containing past key values. |
|
[hasDecoder] | boolean | false | Whether the model has a decoder. |
PreTrainedModel.from_pretrained(pretrained_model_name_or_path, options)
⇒ Promise.<PreTrainedModel>
Instantiate one of the model classes of the library from a pretrained model.
The model class to instantiate is selected based on the model_type
property of the config object
(either passed as an argument or loaded from pretrained_model_name_or_path
if possible)
Kind: static method of PreTrainedModel
Returns: Promise.<PreTrainedModel>
- A new instance of the PreTrainedModel
class.
Param | Type | Description |
---|---|---|
pretrained_model_name_or_path | string | The name or path of the pretrained model. Can be either:
|
options | PretrainedOptions | Additional options for loading the model. |
Base class for model’s outputs, with potential hidden states and attentions.
Kind: static class of models
new BaseModelOutput(output)
Param | Type | Description |
---|---|---|
output | Object | The output of the model. |
output.last_hidden_state | Tensor | Sequence of hidden-states at the output of the last layer of the model. |
[output.hidden_states] | Tensor | Hidden-states of the model at the output of each layer plus the optional initial embedding outputs. |
[output.attentions] | Tensor | Attentions weights after the attention softmax, used to compute the weighted average in the self-attention heads. |
BertPreTrainedModel
BertForMaskedLM is a class representing a BERT model for masked language modeling.
Kind: static class of models
Extends: BertPreTrainedModel
bertForMaskedLM._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
Calls the model on new inputs.
Kind: instance method of BertForMaskedLM
Returns: Promise.<MaskedLMOutput>
- An object containing the model’s output logits for masked language modeling.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
BertPreTrainedModel
BertForSequenceClassification is a class representing a BERT model for sequence classification.
Kind: static class of models
Extends: BertPreTrainedModel
bertForSequenceClassification._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
Calls the model on new inputs.
Kind: instance method of BertForSequenceClassification
Returns: Promise.<SequenceClassifierOutput>
- An object containing the model’s output logits for sequence classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
BertPreTrainedModel
BertForTokenClassification is a class representing a BERT model for token classification.
Kind: static class of models
Extends: BertPreTrainedModel
bertForTokenClassification._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
Calls the model on new inputs.
Kind: instance method of BertForTokenClassification
Returns: Promise.<TokenClassifierOutput>
- An object containing the model’s output logits for token classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
BertPreTrainedModel
BertForQuestionAnswering is a class representing a BERT model for question answering.
Kind: static class of models
Extends: BertPreTrainedModel
bertForQuestionAnswering._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
Calls the model on new inputs.
Kind: instance method of BertForQuestionAnswering
Returns: Promise.<QuestionAnsweringModelOutput>
- An object containing the model’s output logits for question answering.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
The bare CamemBERT Model transformer outputting raw hidden-states without any specific head on top.
Kind: static class of models
CamemBERT Model with a language modeling
head on top.
Kind: static class of models
camembertForMaskedLM._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
Calls the model on new inputs.
Kind: instance method of CamembertForMaskedLM
Returns: Promise.<MaskedLMOutput>
- An object containing the model’s output logits for masked language modeling.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
CamemBERT Model transformer with a sequence classification/regression head on top (a linear layer on top of the pooled output) e.g. for GLUE tasks.
Kind: static class of models
camembertForSequenceClassification._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
Calls the model on new inputs.
Kind: instance method of CamembertForSequenceClassification
Returns: Promise.<SequenceClassifierOutput>
- An object containing the model’s output logits for sequence classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
CamemBERT Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for Named-Entity-Recognition (NER) tasks.
Kind: static class of models
camembertForTokenClassification._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
Calls the model on new inputs.
Kind: instance method of CamembertForTokenClassification
Returns: Promise.<TokenClassifierOutput>
- An object containing the model’s output logits for token classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
CamemBERT Model with a span classification head on top for extractive question-answering tasks
Kind: static class of models
camembertForQuestionAnswering._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
Calls the model on new inputs.
Kind: instance method of CamembertForQuestionAnswering
Returns: Promise.<QuestionAnsweringModelOutput>
- An object containing the model’s output logits for question answering.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
The bare DeBERTa Model transformer outputting raw hidden-states without any specific head on top.
Kind: static class of models
DeBERTa Model with a language modeling
head on top.
Kind: static class of models
debertaForMaskedLM._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
Calls the model on new inputs.
Kind: instance method of DebertaForMaskedLM
Returns: Promise.<MaskedLMOutput>
- An object containing the model’s output logits for masked language modeling.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
DeBERTa Model transformer with a sequence classification/regression head on top (a linear layer on top of the pooled output)
Kind: static class of models
debertaForSequenceClassification._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
Calls the model on new inputs.
Kind: instance method of DebertaForSequenceClassification
Returns: Promise.<SequenceClassifierOutput>
- An object containing the model’s output logits for sequence classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
DeBERTa Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for Named-Entity-Recognition (NER) tasks.
Kind: static class of models
debertaForTokenClassification._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
Calls the model on new inputs.
Kind: instance method of DebertaForTokenClassification
Returns: Promise.<TokenClassifierOutput>
- An object containing the model’s output logits for token classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
DeBERTa Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear
layers on top of the hidden-states output to compute span start logits
and span end logits
).
Kind: static class of models
debertaForQuestionAnswering._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
Calls the model on new inputs.
Kind: instance method of DebertaForQuestionAnswering
Returns: Promise.<QuestionAnsweringModelOutput>
- An object containing the model’s output logits for question answering.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
The bare DeBERTa-V2 Model transformer outputting raw hidden-states without any specific head on top.
Kind: static class of models
DeBERTa-V2 Model with a language modeling
head on top.
Kind: static class of models
debertaV2ForMaskedLM._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
Calls the model on new inputs.
Kind: instance method of DebertaV2ForMaskedLM
Returns: Promise.<MaskedLMOutput>
- An object containing the model’s output logits for masked language modeling.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
DeBERTa-V2 Model transformer with a sequence classification/regression head on top (a linear layer on top of the pooled output)
Kind: static class of models
debertaV2ForSequenceClassification._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
Calls the model on new inputs.
Kind: instance method of DebertaV2ForSequenceClassification
Returns: Promise.<SequenceClassifierOutput>
- An object containing the model’s output logits for sequence classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
DeBERTa-V2 Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for Named-Entity-Recognition (NER) tasks.
Kind: static class of models
debertaV2ForTokenClassification._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
Calls the model on new inputs.
Kind: instance method of DebertaV2ForTokenClassification
Returns: Promise.<TokenClassifierOutput>
- An object containing the model’s output logits for token classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
DeBERTa-V2 Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear
layers on top of the hidden-states output to compute span start logits
and span end logits
).
Kind: static class of models
debertaV2ForQuestionAnswering._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
Calls the model on new inputs.
Kind: instance method of DebertaV2ForQuestionAnswering
Returns: Promise.<QuestionAnsweringModelOutput>
- An object containing the model’s output logits for question answering.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
DistilBertPreTrainedModel
DistilBertForSequenceClassification is a class representing a DistilBERT model for sequence classification.
Kind: static class of models
Extends: DistilBertPreTrainedModel
distilBertForSequenceClassification._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
Calls the model on new inputs.
Kind: instance method of DistilBertForSequenceClassification
Returns: Promise.<SequenceClassifierOutput>
- An object containing the model’s output logits for sequence classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
DistilBertPreTrainedModel
DistilBertForTokenClassification is a class representing a DistilBERT model for token classification.
Kind: static class of models
Extends: DistilBertPreTrainedModel
distilBertForTokenClassification._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
Calls the model on new inputs.
Kind: instance method of DistilBertForTokenClassification
Returns: Promise.<TokenClassifierOutput>
- An object containing the model’s output logits for token classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
DistilBertPreTrainedModel
DistilBertForQuestionAnswering is a class representing a DistilBERT model for question answering.
Kind: static class of models
Extends: DistilBertPreTrainedModel
distilBertForQuestionAnswering._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
Calls the model on new inputs.
Kind: instance method of DistilBertForQuestionAnswering
Returns: Promise.<QuestionAnsweringModelOutput>
- An object containing the model’s output logits for question answering.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
DistilBertPreTrainedModel
DistilBertForMaskedLM is a class representing a DistilBERT model for masking task.
Kind: static class of models
Extends: DistilBertPreTrainedModel
distilBertForMaskedLM._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
Calls the model on new inputs.
Kind: instance method of DistilBertForMaskedLM
Returns: Promise.<MaskedLMOutput>
- returned object
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
MobileBertPreTrainedModel
MobileBertForMaskedLM is a class representing a MobileBERT model for masking task.
Kind: static class of models
Extends: MobileBertPreTrainedModel
mobileBertForMaskedLM._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
Calls the model on new inputs.
Kind: instance method of MobileBertForMaskedLM
Returns: Promise.<MaskedLMOutput>
- returned object
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
MobileBertPreTrainedModel
Kind: static class of models
Extends: MobileBertPreTrainedModel
mobileBertForSequenceClassification._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
Calls the model on new inputs.
Kind: instance method of MobileBertForSequenceClassification
Returns: Promise.<SequenceClassifierOutput>
- returned object
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
MobileBertPreTrainedModel
Kind: static class of models
Extends: MobileBertPreTrainedModel
mobileBertForQuestionAnswering._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
Calls the model on new inputs.
Kind: instance method of MobileBertForQuestionAnswering
Returns: Promise.<QuestionAnsweringModelOutput>
- returned object
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
MPNetPreTrainedModel
The bare MPNet Model transformer outputting raw hidden-states without any specific head on top.
Kind: static class of models
Extends: MPNetPreTrainedModel
MPNetPreTrainedModel
MPNetForMaskedLM is a class representing a MPNet model for masked language modeling.
Kind: static class of models
Extends: MPNetPreTrainedModel
mpNetForMaskedLM._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
Calls the model on new inputs.
Kind: instance method of MPNetForMaskedLM
Returns: Promise.<MaskedLMOutput>
- An object containing the model’s output logits for masked language modeling.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
MPNetPreTrainedModel
MPNetForSequenceClassification is a class representing a MPNet model for sequence classification.
Kind: static class of models
Extends: MPNetPreTrainedModel
mpNetForSequenceClassification._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
Calls the model on new inputs.
Kind: instance method of MPNetForSequenceClassification
Returns: Promise.<SequenceClassifierOutput>
- An object containing the model’s output logits for sequence classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
MPNetPreTrainedModel
MPNetForTokenClassification is a class representing a MPNet model for token classification.
Kind: static class of models
Extends: MPNetPreTrainedModel
mpNetForTokenClassification._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
Calls the model on new inputs.
Kind: instance method of MPNetForTokenClassification
Returns: Promise.<TokenClassifierOutput>
- An object containing the model’s output logits for token classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
MPNetPreTrainedModel
MPNetForQuestionAnswering is a class representing a MPNet model for question answering.
Kind: static class of models
Extends: MPNetPreTrainedModel
mpNetForQuestionAnswering._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
Calls the model on new inputs.
Kind: instance method of MPNetForQuestionAnswering
Returns: Promise.<QuestionAnsweringModelOutput>
- An object containing the model’s output logits for question answering.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
T5PreTrainedModel
T5Model is a class representing a T5 model for conditional generation.
Kind: static class of models
Extends: T5PreTrainedModel
new T5ForConditionalGeneration(config, session, decoder_merged_session, generation_config)
Creates a new instance of the T5ForConditionalGeneration
class.
Param | Type | Description |
---|---|---|
config | Object | The model configuration. |
session | any | session for the model. |
decoder_merged_session | any | session for the decoder. |
generation_config | GenerationConfig | The generation configuration. |
MT5PreTrainedModel
A class representing a conditional sequence-to-sequence model based on the MT5 architecture.
Kind: static class of models
Extends: MT5PreTrainedModel
new MT5ForConditionalGeneration(config, session, decoder_merged_session, generation_config)
Creates a new instance of the MT5ForConditionalGeneration
class.
Param | Type | Description |
---|---|---|
config | any | The model configuration. |
session | any | The ONNX session containing the encoder weights. |
decoder_merged_session | any | The ONNX session containing the merged decoder weights. |
generation_config | GenerationConfig | The generation configuration. |
BartPretrainedModel
BART encoder and decoder model.
Kind: static class of models
Extends: BartPretrainedModel
BartPretrainedModel
BART model with a language model head for conditional generation.
Kind: static class of models
Extends: BartPretrainedModel
new BartForConditionalGeneration(config, session, decoder_merged_session, generation_config)
Creates a new instance of the BartForConditionalGeneration
class.
Param | Type | Description |
---|---|---|
config | Object | The configuration object for the Bart model. |
session | Object | The ONNX session used to execute the model. |
decoder_merged_session | Object | The ONNX session used to execute the decoder. |
generation_config | Object | The generation configuration object. |
The bare MBART Model outputting raw hidden-states without any specific head on top.
Kind: static class of models
The MBART Model with a language modeling head. Can be used for summarization, after fine-tuning the pretrained models.
Kind: static class of models
new MBartForConditionalGeneration(config, session, decoder_merged_session, generation_config)
Creates a new instance of the MBartForConditionalGeneration
class.
Param | Type | Description |
---|---|---|
config | Object | The configuration object for the Bart model. |
session | Object | The ONNX session used to execute the model. |
decoder_merged_session | Object | The ONNX session used to execute the decoder. |
generation_config | Object | The generation configuration object. |
MBart model with a sequence classification/head on top (a linear layer on top of the pooled output).
Kind: static class of models
mBartForSequenceClassification._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
Calls the model on new inputs.
Kind: instance method of MBartForSequenceClassification
Returns: Promise.<SequenceClassifierOutput>
- An object containing the model’s output logits for sequence classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
RobertaPreTrainedModel
RobertaForMaskedLM class for performing masked language modeling on Roberta models.
Kind: static class of models
Extends: RobertaPreTrainedModel
robertaForMaskedLM._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
Calls the model on new inputs.
Kind: instance method of RobertaForMaskedLM
Returns: Promise.<MaskedLMOutput>
- returned object
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
RobertaPreTrainedModel
RobertaForSequenceClassification class for performing sequence classification on Roberta models.
Kind: static class of models
Extends: RobertaPreTrainedModel
robertaForSequenceClassification._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
Calls the model on new inputs.
Kind: instance method of RobertaForSequenceClassification
Returns: Promise.<SequenceClassifierOutput>
- returned object
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
RobertaPreTrainedModel
RobertaForTokenClassification class for performing token classification on Roberta models.
Kind: static class of models
Extends: RobertaPreTrainedModel
robertaForTokenClassification._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
Calls the model on new inputs.
Kind: instance method of RobertaForTokenClassification
Returns: Promise.<TokenClassifierOutput>
- An object containing the model’s output logits for token classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
RobertaPreTrainedModel
RobertaForQuestionAnswering class for performing question answering on Roberta models.
Kind: static class of models
Extends: RobertaPreTrainedModel
robertaForQuestionAnswering._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
Calls the model on new inputs.
Kind: instance method of RobertaForQuestionAnswering
Returns: Promise.<QuestionAnsweringModelOutput>
- returned object
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained models.
Kind: static class of models
The bare XLM Model transformer outputting raw hidden-states without any specific head on top.
Kind: static class of models
The XLM Model transformer with a language modeling head on top (linear layer with weights tied to the input embeddings).
Kind: static class of models
xlmWithLMHeadModel._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
Calls the model on new inputs.
Kind: instance method of XLMWithLMHeadModel
Returns: Promise.<MaskedLMOutput>
- returned object
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
XLM Model with a sequence classification/regression head on top (a linear layer on top of the pooled output)
Kind: static class of models
xlmForSequenceClassification._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
Calls the model on new inputs.
Kind: instance method of XLMForSequenceClassification
Returns: Promise.<SequenceClassifierOutput>
- returned object
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
XLM Model with a token classification head on top (a linear layer on top of the hidden-states output)
Kind: static class of models
xlmForTokenClassification._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
Calls the model on new inputs.
Kind: instance method of XLMForTokenClassification
Returns: Promise.<TokenClassifierOutput>
- An object containing the model’s output logits for token classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
XLM Model with a span classification head on top for extractive question-answering tasks
Kind: static class of models
xlmForQuestionAnswering._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
Calls the model on new inputs.
Kind: instance method of XLMForQuestionAnswering
Returns: Promise.<QuestionAnsweringModelOutput>
- returned object
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
XLMRobertaPreTrainedModel
XLMRobertaForMaskedLM class for performing masked language modeling on XLMRoberta models.
Kind: static class of models
Extends: XLMRobertaPreTrainedModel
xlmRobertaForMaskedLM._call(model_inputs)
⇒ Promise.<MaskedLMOutput>
Calls the model on new inputs.
Kind: instance method of XLMRobertaForMaskedLM
Returns: Promise.<MaskedLMOutput>
- returned object
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
XLMRobertaPreTrainedModel
XLMRobertaForSequenceClassification class for performing sequence classification on XLMRoberta models.
Kind: static class of models
Extends: XLMRobertaPreTrainedModel
xlmRobertaForSequenceClassification._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
Calls the model on new inputs.
Kind: instance method of XLMRobertaForSequenceClassification
Returns: Promise.<SequenceClassifierOutput>
- returned object
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
XLMRobertaPreTrainedModel
XLMRobertaForTokenClassification class for performing token classification on XLMRoberta models.
Kind: static class of models
Extends: XLMRobertaPreTrainedModel
xlmRobertaForTokenClassification._call(model_inputs)
⇒ Promise.<TokenClassifierOutput>
Calls the model on new inputs.
Kind: instance method of XLMRobertaForTokenClassification
Returns: Promise.<TokenClassifierOutput>
- An object containing the model’s output logits for token classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
XLMRobertaPreTrainedModel
XLMRobertaForQuestionAnswering class for performing question answering on XLMRoberta models.
Kind: static class of models
Extends: XLMRobertaPreTrainedModel
xlmRobertaForQuestionAnswering._call(model_inputs)
⇒ Promise.<QuestionAnsweringModelOutput>
Calls the model on new inputs.
Kind: instance method of XLMRobertaForQuestionAnswering
Returns: Promise.<QuestionAnsweringModelOutput>
- returned object
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
WhisperPreTrainedModel
WhisperModel class for training Whisper models without a language model head.
Kind: static class of models
Extends: WhisperPreTrainedModel
WhisperPreTrainedModel
WhisperForConditionalGeneration class for generating conditional outputs from Whisper models.
Kind: static class of models
Extends: WhisperPreTrainedModel
WhisperPreTrainedModel
new WhisperForConditionalGeneration(config, session, decoder_merged_session, generation_config)
Creates a new instance of the WhisperForConditionalGeneration
class.
Param | Type | Description |
---|---|---|
config | Object | Configuration object for the model. |
session | Object | ONNX Session object for the model. |
decoder_merged_session | Object | ONNX Session object for the decoder. |
generation_config | Object | Configuration object for the generation process. |
whisperForConditionalGeneration.generate(inputs, generation_config, logits_processor)
⇒ Promise.<Object>
Generates outputs based on input and generation configuration.
Kind: instance method of WhisperForConditionalGeneration
Returns: Promise.<Object>
- Promise object represents the generated outputs.
Param | Type | Default | Description |
---|---|---|---|
inputs | Object | Input data for the model. |
|
generation_config | WhisperGenerationConfig |
| Configuration object for the generation process. |
logits_processor | Object |
| Optional logits processor object. |
whisperForConditionalGeneration._extract_token_timestamps(generate_outputs, alignment_heads, [num_frames], [time_precision])
⇒ Tensor
Calculates token-level timestamps using the encoder-decoder cross-attentions and dynamic time-warping (DTW) to map each output token to a position in the input audio.
Kind: instance method of WhisperForConditionalGeneration
Returns: Tensor
- tensor containing the timestamps in seconds for each predicted token
Param | Type | Default | Description |
---|---|---|---|
generate_outputs | Object | Outputs generated by the model |
|
generate_outputs.cross_attentions | Array.<Array<Array<Tensor>>> | The cross attentions output by the model |
|
generate_outputs.decoder_attentions | Array.<Array<Array<Tensor>>> | The decoder attentions output by the model |
|
generate_outputs.sequences | Array.<Array<number>> | The sequences output by the model |
|
alignment_heads | Array.<Array<number>> | Alignment heads of the model |
|
[num_frames] | number |
| Number of frames in the input audio. |
[time_precision] | number | 0.02 | Precision of the timestamps in seconds |
PreTrainedModel
Vision Encoder-Decoder model based on OpenAI’s GPT architecture for image captioning and other vision tasks
Kind: static class of models
Extends: PreTrainedModel
new VisionEncoderDecoderModel(config, session, decoder_merged_session)
Creates a new instance of the VisionEncoderDecoderModel
class.
Param | Type | Description |
---|---|---|
config | Object | The configuration object specifying the hyperparameters and other model settings. |
session | Object | The ONNX session containing the encoder model. |
decoder_merged_session | any | The ONNX session containing the merged decoder model. |
CLIP Text and Vision Model with a projection layers on top
Example: Perform zero-shot image classification with a 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) [ ... ],
// }
// }
Kind: static class of models
CLIP Text Model with a projection layer on top (a linear layer on top of the pooled output)
Example: Compute text embeddings with 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
// }
Kind: static class of models
CLIPTextModelWithProjection.from_pretrained()
: PreTrainedModel.from_pretrained
Kind: static method of CLIPTextModelWithProjection
CLIP Vision Model with a projection layer on top (a linear layer on top of the pooled output)
Example: Compute vision embeddings with 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
// }
Kind: static class of models
CLIPVisionModelWithProjection.from_pretrained()
: PreTrainedModel.from_pretrained
Kind: static method of CLIPVisionModelWithProjection
Kind: static class of models
new GPT2PreTrainedModel(config, session)
Creates a new instance of the GPT2PreTrainedModel
class.
Param | Type | Description |
---|---|---|
config | Object | The configuration of the model. |
session | any | The ONNX session containing the model weights. |
GPT2PreTrainedModel
GPT-2 language model head on top of the GPT-2 base model. This model is suitable for text generation tasks.
Kind: static class of models
Extends: GPT2PreTrainedModel
Kind: static class of models
new GPTNeoPreTrainedModel(config, session)
Creates a new instance of the GPTNeoPreTrainedModel
class.
Param | Type | Description |
---|---|---|
config | Object | The configuration of the model. |
session | any | The ONNX session containing the model weights. |
Kind: static class of models
new GPTNeoXPreTrainedModel(config, session)
Creates a new instance of the GPTNeoXPreTrainedModel
class.
Param | Type | Description |
---|---|---|
config | Object | The configuration of the model. |
session | any | The ONNX session containing the model weights. |
Kind: static class of models
new GPTJPreTrainedModel(config, session)
Creates a new instance of the GPTJPreTrainedModel
class.
Param | Type | Description |
---|---|---|
config | Object | The configuration of the model. |
session | any | The ONNX session containing the model weights. |
Kind: static class of models
new GPTBigCodePreTrainedModel(config, session)
Creates a new instance of the GPTBigCodePreTrainedModel
class.
Param | Type | Description |
---|---|---|
config | Object | The configuration of the model. |
session | any | The ONNX session containing the model weights. |
Kind: static class of models
new CodeGenPreTrainedModel(config, session)
Creates a new instance of the CodeGenPreTrainedModel
class.
Param | Type | Description |
---|---|---|
config | Object | The model configuration object. |
session | Object | The ONNX session object. |
CodeGenPreTrainedModel
CodeGenModel is a class representing a code generation model without a language model head.
Kind: static class of models
Extends: CodeGenPreTrainedModel
CodeGenPreTrainedModel
CodeGenForCausalLM is a class that represents a code generation model based on the GPT-2 architecture. It extends the CodeGenPreTrainedModel
class.
Kind: static class of models
Extends: CodeGenPreTrainedModel
The bare LLama Model outputting raw hidden-states without any specific head on top.
Kind: static class of models
new LlamaPreTrainedModel(config, session)
Creates a new instance of the LlamaPreTrainedModel
class.
Param | Type | Description |
---|---|---|
config | Object | The model configuration object. |
session | Object | The ONNX session object. |
The bare LLaMA Model outputting raw hidden-states without any specific head on top.
Kind: static class of models
The Bloom Model transformer with a language modeling head on top (linear layer with weights tied to the input embeddings).
Kind: static class of models
new BloomPreTrainedModel(config, session)
Creates a new instance of the BloomPreTrainedModel
class.
Param | Type | Description |
---|---|---|
config | Object | The configuration of the model. |
session | any | The ONNX session containing the model weights. |
The bare Bloom Model transformer outputting raw hidden-states without any specific head on top.
Kind: static class of models
The Bloom Model transformer with a language modeling head on top (linear layer with weights tied to the input embeddings).
Kind: static class of models
Kind: static class of models
new MptPreTrainedModel(config, session)
Creates a new instance of the MptPreTrainedModel
class.
Param | Type | Description |
---|---|---|
config | Object | The model configuration object. |
session | Object | The ONNX session object. |
The bare Mpt Model transformer outputting raw hidden-states without any specific head on top.
Kind: static class of models
The MPT Model transformer with a language modeling head on top (linear layer with weights tied to the input embeddings).
Kind: static class of models
Kind: static class of models
new OPTPreTrainedModel(config, session)
Creates a new instance of the OPTPreTrainedModel
class.
Param | Type | Description |
---|---|---|
config | Object | The model configuration object. |
session | Object | The ONNX session object. |
The bare OPT Model outputting raw hidden-states without any specific head on top.
Kind: static class of models
The OPT Model transformer with a language modeling head on top (linear layer with weights tied to the input embeddings).
Kind: static class of models
Kind: static class of models
new DetrObjectDetectionOutput(output)
Param | Type | Description |
---|---|---|
output | Object | The output of the model. |
output.logits | Tensor | Classification logits (including no-object) for all queries. |
output.pred_boxes | Tensor | Normalized boxes coordinates for all queries, represented as (center_x, center_y, width, height). These values are normalized in [0, 1], relative to the size of each individual image in the batch (disregarding possible padding). |
Kind: static class of models
new DetrSegmentationOutput(output)
Param | Type | Description |
---|---|---|
output | Object | The output of the model. |
output.logits | Tensor | The output logits of the model. |
output.pred_boxes | Tensor | Predicted boxes. |
output.pred_masks | Tensor | Predicted masks. |
An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained models.
Kind: static class of models
The bare ResNet model outputting raw features without any specific head on top.
Kind: static class of models
ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for ImageNet.
Kind: static class of models
resNetForImageClassification._call(model_inputs)
Kind: instance method of ResNetForImageClassification
Param | Type |
---|---|
model_inputs | any |
Kind: static class of models
new YolosObjectDetectionOutput(output)
Param | Type | Description |
---|---|---|
output | Object | The output of the model. |
output.logits | Tensor | Classification logits (including no-object) for all queries. |
output.pred_boxes | Tensor | Normalized boxes coordinates for all queries, represented as (center_x, center_y, width, height). These values are normalized in [0, 1], relative to the size of each individual image in the batch (disregarding possible padding). |
Base class for Segment-Anything model’s output.
Kind: static class of models
new SamImageSegmentationOutput(output)
Param | Type | Description |
---|---|---|
output | Object | The output of the model. |
output.iou_scores | Tensor | The output logits of the model. |
output.pred_masks | Tensor | Predicted boxes. |
Kind: static class of models
new MarianMTModel(config, session, decoder_merged_session, generation_config)
.forward(model_inputs)
⇒ Promise.<Seq2SeqLMOutput>
new MarianMTModel(config, session, decoder_merged_session, generation_config)
Creates a new instance of the MarianMTModel
class.
Param | Type | Description |
---|---|---|
config | Object | The model configuration object. |
session | Object | The ONNX session object. |
decoder_merged_session | any | |
generation_config | any |
marianMTModel.forward(model_inputs)
⇒ Promise.<Seq2SeqLMOutput>
Kind: instance method of MarianMTModel
Param | Type |
---|---|
model_inputs | any |
Kind: static class of models
new M2M100ForConditionalGeneration(config, session, decoder_merged_session, generation_config)
.forward(model_inputs)
⇒ Promise.<Seq2SeqLMOutput>
new M2M100ForConditionalGeneration(config, session, decoder_merged_session, generation_config)
Creates a new instance of the M2M100ForConditionalGeneration
class.
Param | Type | Description |
---|---|---|
config | Object | The model configuration object. |
session | Object | The ONNX session object. |
decoder_merged_session | any | |
generation_config | any |
m2M100ForConditionalGeneration.forward(model_inputs)
⇒ Promise.<Seq2SeqLMOutput>
Kind: instance method of M2M100ForConditionalGeneration
Param | Type |
---|---|
model_inputs | any |
The bare Wav2Vec2 Model transformer outputting raw hidden-states without any specific head on top.
Example: Load and run an Wav2Vec2Model
for feature extraction.
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
// }
// }
Kind: static class of models
An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained models.
Kind: static class of models
The bare WavLM Model transformer outputting raw hidden-states without any specific head on top.
Example: Load and run an WavLMModel
for feature extraction.
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
// }
// }
Kind: static class of models
WavLM Model with a language modeling
head on top for Connectionist Temporal Classification (CTC).
Kind: static class of models
wavLMForCTC._call(model_inputs)
Kind: instance method of WavLMForCTC
Param | Type | Description |
---|---|---|
model_inputs | Object | |
model_inputs.input_values | Tensor | Float values of input raw speech waveform. |
model_inputs.attention_mask | Tensor | Mask to avoid performing convolution and attention on padding token indices. Mask values selected in [0, 1] |
WavLM Model with a sequence classification head on top (a linear layer over the pooled output).
Kind: static class of models
wavLMForSequenceClassification._call(model_inputs)
⇒ Promise.<SequenceClassifierOutput>
Calls the model on new inputs.
Kind: instance method of WavLMForSequenceClassification
Returns: Promise.<SequenceClassifierOutput>
- An object containing the model’s output logits for sequence classification.
Param | Type | Description |
---|---|---|
model_inputs | Object | The inputs to the model. |
Base class of all AutoModels. Contains the from_pretrained
function
which is used to instantiate pretrained models.
Kind: static class of models
.from_pretrained()
: PreTrainedModel.from_pretrained
pretrainedMixin.MODEL_CLASS_MAPPINGS
: *
Mapping from model type to model class.
Kind: instance property of PretrainedMixin
pretrainedMixin.BASE_IF_FAIL
Whether to attempt to instantiate the base class (PretrainedModel
) if
the model type is not found in the mapping.
Kind: instance property of PretrainedMixin
PretrainedMixin.from_pretrained()
: PreTrainedModel.from_pretrained
Kind: static method of PretrainedMixin
Helper class which is used to instantiate pretrained models with the from_pretrained
function.
The chosen model class is determined by the type specified in the model config.
Kind: static class of models
Helper class which is used to instantiate pretrained sequence classification models with the from_pretrained
function.
The chosen model class is determined by the type specified in the model config.
Kind: static class of models
Helper class which is used to instantiate pretrained token classification models with the from_pretrained
function.
The chosen model class is determined by the type specified in the model config.
Kind: static class of models
Helper class which is used to instantiate pretrained sequence-to-sequence models with the from_pretrained
function.
The chosen model class is determined by the type specified in the model config.
Kind: static class of models
Helper class which is used to instantiate pretrained causal language models with the from_pretrained
function.
The chosen model class is determined by the type specified in the model config.
Kind: static class of models
Helper class which is used to instantiate pretrained masked language models with the from_pretrained
function.
The chosen model class is determined by the type specified in the model config.
Kind: static class of models
Helper class which is used to instantiate pretrained question answering models with the from_pretrained
function.
The chosen model class is determined by the type specified in the model config.
Kind: static class of models
Helper class which is used to instantiate pretrained vision-to-sequence models with the from_pretrained
function.
The chosen model class is determined by the type specified in the model config.
Kind: static class of models
Helper class which is used to instantiate pretrained image classification models with the from_pretrained
function.
The chosen model class is determined by the type specified in the model config.
Kind: static class of models
Helper class which is used to instantiate pretrained image segmentation models with the from_pretrained
function.
The chosen model class is determined by the type specified in the model config.
Kind: static class of models
Helper class which is used to instantiate pretrained object detection models with the from_pretrained
function.
The chosen model class is determined by the type specified in the model config.
Kind: static class of models
Helper class which is used to instantiate pretrained object detection models with the from_pretrained
function.
The chosen model class is determined by the type specified in the model config.
Kind: static class of models
Kind: static class of models
new Seq2SeqLMOutput(output)
Param | Type | Description |
---|---|---|
output | Object | The output of the model. |
output.logits | Tensor | The output logits of the model. |
output.past_key_values | Tensor | An tensor of key/value pairs that represent the previous state of the model. |
output.encoder_outputs | Tensor | The output of the encoder in a sequence-to-sequence model. |
[output.decoder_attentions] | Tensor | Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the self-attention heads. |
[output.cross_attentions] | Tensor | Attentions weights of the decoder's cross-attention layer, after the attention softmax, used to compute the weighted average in the cross-attention heads. |
Base class for outputs of sentence classification models.
Kind: static class of models
new SequenceClassifierOutput(output)
Param | Type | Description |
---|---|---|
output | Object | The output of the model. |
output.logits | Tensor | classification (or regression if config.num_labels==1) scores (before SoftMax). |
Base class for outputs of token classification models.
Kind: static class of models
new TokenClassifierOutput(output)
Param | Type | Description |
---|---|---|
output | Object | The output of the model. |
output.logits | Tensor | Classification scores (before SoftMax). |
Base class for masked language models outputs.
Kind: static class of models
new MaskedLMOutput(output)
Param | Type | Description |
---|---|---|
output | Object | The output of the model. |
output.logits | Tensor | Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax). |
Base class for outputs of question answering models.
Kind: static class of models
new QuestionAnsweringModelOutput(output)
Param | Type | Description |
---|---|---|
output | Object | The output of the model. |
output.start_logits | Tensor | Span-start scores (before SoftMax). |
output.end_logits | Tensor | Span-end scores (before SoftMax). |
Base class for causal language model (or autoregressive) outputs.
Kind: static class of models
new CausalLMOutput(output)
Param | Type | Description |
---|---|---|
output | Object | The output of the model. |
output.logits | Tensor | Prediction scores of the language modeling head (scores for each vocabulary token before softmax). |
Base class for causal language model (or autoregressive) outputs.
Kind: static class of models
new CausalLMOutputWithPast(output)
Param | Type | Description |
---|---|---|
output | Object | The output of the model. |
output.logits | Tensor | Prediction scores of the language modeling head (scores for each vocabulary token before softmax). |
output.past_key_values | Tensor | Contains pre-computed hidden-states (key and values in the self-attention blocks)
that can be used (see |
models~PretrainedOptions
: *
Kind: inner typedef of models
models~TypedArray
: *
Kind: inner typedef of models
models~DecoderOutput
⇒ Promise.<(Array<Array<number>>|EncoderDecoderOutput|DecoderOutput)>
Generates text based on the given inputs and generation configuration using the model.
Kind: inner typedef of models
Returns: Promise.<(Array<Array<number>>|EncoderDecoderOutput|DecoderOutput)>
- An array of generated output sequences, where each sequence is an array of token IDs.
Throws:
Error
Throws an error if the inputs array is empty.Param | Type | Default | Description |
---|---|---|---|
inputs | Tensor | Array | TypedArray | An array of input token IDs. |
|
generation_config | Object | GenerationConfig | null | The generation configuration to use. If null, default configuration will be used. |
|
logits_processor | Object | null | An optional logits processor to use. If null, a new LogitsProcessorList instance will be created. |
|
options | Object | options |
|
[options.inputs_attention_mask] | Object |
| An optional attention mask for the inputs. |
models~WhisperGenerationConfig
: Object
Kind: inner typedef of models
Extends: GenerationConfig
Properties
Name | Type | Default | Description |
---|---|---|---|
[return_timestamps] | boolean |
| Whether to return the timestamps with the text. This enables the |
[return_token_timestamps] | boolean |
| Whether to return token-level timestamps
with the text. This can be used with or without the |
[num_frames] | number |
| The number of audio frames available in this chunk. This is only used generating word-level timestamps. |