start_top_log_probs (torch.FloatTensor of shape (batch_size, config.start_n_top), optional, returned if start_positions or end_positions is not provided) —\nLog probabilities for the top config.start_n_top start token possibilities (beam-search).
start_top_index (torch.LongTensor of shape (batch_size, config.start_n_top), optional, returned if start_positions or end_positions is not provided) —\nIndices for the top config.start_n_top start token possibilities (beam-search).
end_top_log_probs (torch.FloatTensor of shape (batch_size, config.start_n_top * config.end_n_top), optional, returned if start_positions or end_positions is not provided) —\nLog probabilities for the top config.start_n_top * config.end_n_top end token possibilities\n(beam-search).
end_top_index (torch.LongTensor of shape (batch_size, config.start_n_top * config.end_n_top), optional, returned if start_positions or end_positions is not provided) —\nIndices for the top config.start_n_top * config.end_n_top end token possibilities (beam-search).
cls_logits (torch.FloatTensor of shape (batch_size,), optional, returned if start_positions or end_positions is not provided) —\nLog probabilities for the is_impossible label of the answers.
mems (List[torch.FloatTensor] of length config.n_layers) —\nContains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) —\nTuple of torch.FloatTensor (one for the output of the embeddings + one for the output of each layer) of\nshape (batch_size, sequence_length, hidden_size).\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) —\nTuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
last_hidden_state (tf.Tensor of shape (batch_size, num_predict, hidden_size)) —\nSequence of hidden-states at the last layer of the model.\n
num_predict corresponds to target_mapping.shape[1]. If target_mapping is None, then num_predict\ncorresponds to sequence_length.
mems (List[tf.Tensor] of length config.n_layers) —\nContains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) —\nTuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape\n(batch_size, sequence_length, hidden_size).\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) —\nTuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
loss (tf.Tensor of shape (1,), optional, returned when labels is provided) —\nLanguage modeling loss (for next-token prediction).
logits (tf.Tensor of shape (batch_size, num_predict, config.vocab_size)) —\nPrediction scores of the language modeling head (scores for each vocabulary token before SoftMax).\n
num_predict corresponds to target_mapping.shape[1]. If target_mapping is None, then num_predict\ncorresponds to sequence_length.
mems (List[tf.Tensor] of length config.n_layers) —\nContains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) —\nTuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape\n(batch_size, sequence_length, hidden_size).\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) —\nTuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
loss (tf.Tensor of shape (1,), optional, returned when label is provided) —\nClassification (or regression if config.num_labels==1) loss.
logits (tf.Tensor of shape (batch_size, config.num_labels)) —\nClassification (or regression if config.num_labels==1) scores (before SoftMax).
mems (List[tf.Tensor] of length config.n_layers) —\nContains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) —\nTuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape\n(batch_size, sequence_length, hidden_size).\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) —\nTuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
loss (tf.Tensor of shape (1,), optional, returned when labels is provided) —\nClassification loss.
logits (tf.Tensor of shape (batch_size, num_choices)) —\nnum_choices is the second dimension of the input tensors. (see input_ids above).\n
Classification scores (before SoftMax).
mems (List[tf.Tensor] of length config.n_layers) —\nContains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) —\nTuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape\n(batch_size, sequence_length, hidden_size).\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) —\nTuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
mems (List[tf.Tensor] of length config.n_layers) —\nContains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) —\nTuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape\n(batch_size, sequence_length, hidden_size).\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) —\nTuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
Output type of TFXLNetForTokenClassificationOutput.
loss (tf.Tensor of shape (1,), optional, returned when labels is provided) —\nTotal span extraction loss is the sum of a Cross-Entropy for the start and end positions.
start_logits (tf.Tensor of shape (batch_size, sequence_length,)) —\nSpan-start scores (before SoftMax).
end_logits (tf.Tensor of shape (batch_size, sequence_length,)) —\nSpan-end scores (before SoftMax).
mems (List[tf.Tensor] of length config.n_layers) —\nContains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) —\nTuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape\n(batch_size, sequence_length, hidden_size).\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) —\nTuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
config (XLNetConfig) — Model configuration class with all the parameters of the model.\nInitializing with a config file does not load the weights associated with the model, only the\nconfiguration. Check out the from_pretrained() method to load the model weights.
The bare XLNet Model transformer outputting raw hidden-states without any specific head on top.
This model inherits from PreTrainedModel. Check the superclass documentation for the generic methods the\nlibrary implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\netc.)
This model is also a PyTorch torch.nn.Module subclass.\nUse it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage\nand behavior.
mems (List[torch.FloatTensor] of length config.n_layers) —\nContains pre-computed hidden-states (see mems output below) . Can be used to speed up sequential\ndecoding. The token ids which have their past given to this model should not be passed as input_ids as\nthey have already been computed.\n
use_mems has to be set to True to make use of mems.
perm_mask (torch.FloatTensor of shape (batch_size, sequence_length, sequence_length), optional) —\nMask to indicate the attention pattern for each input token with values selected in [0, 1]:\n
\n
if perm_mask[k, i, j] = 0, i attend to j in batch k;
\n
if perm_mask[k, i, j] = 1, i does not attend to j in batch k.
\n
\n
If not set, each token attends to all the others (full bidirectional attention). Only used during\npretraining (to define factorization order) or for sequential decoding (generation).
target_mapping (torch.FloatTensor of shape (batch_size, num_predict, sequence_length), optional) —\nMask to indicate the output tokens to use. If target_mapping[k, i, j] = 1, the i-th predict in batch k is\non the j-th token. Only used during pretraining for partial prediction or for sequential decoding\n(generation).
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) —\nSegment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:\n
input_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) —\nMask to avoid performing attention on padding token indices. Negative of attention_mask, i.e. with 0 for\nreal tokens and 1 for padding which is kept for compatibility with the original code base.\n
Mask values selected in [0, 1]:
\n
\n
1 for tokens that are masked,
\n
0 for tokens that are not masked.
\n
\n
You can only uses one of input_mask and attention_mask.
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) —\nMask to nullify selected heads of the self-attention modules. Mask values selected in [0, 1]:\n
\n
1 indicates the head is not masked,
\n
0 indicates the head is masked.
\n
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) —\nOptionally, instead of passing input_ids you can choose to directly pass an embedded representation. This\nis useful if you want more control over how to convert input_ids indices into associated vectors than the\nmodel’s internal embedding lookup matrix.
output_attentions (bool, optional) —\nWhether or not to return the attentions tensors of all attention layers. See attentions under returned\ntensors for more detail.
output_hidden_states (bool, optional) —\nWhether or not to return the hidden states of all layers. See hidden_states under returned tensors for\nmore detail.
return_dict (bool, optional) —\nWhether or not to return a ModelOutput instead of a plain tuple.
last_hidden_state (torch.FloatTensor of shape (batch_size, num_predict, hidden_size)) — Sequence of hidden-states at the last layer of the model.
\n
num_predict corresponds to target_mapping.shape[1]. If target_mapping is None, then num_predict\ncorresponds to sequence_length.
\n
\n
\n
mems (List[torch.FloatTensor] of length config.n_layers) — Contains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
\n
\n
\n
hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings + one for the output of each layer) of\nshape (batch_size, sequence_length, hidden_size).
\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
\n
\n
\n
attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).
\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
\n
\n
\n
The XLNetModel forward method, overrides the __call__ special method.
Although the recipe for forward pass needs to be defined within this function, one should call the Module\ninstance afterwards instead of this since the former takes care of running the pre and post processing steps while\nthe latter silently ignores them.
Example:
>>> from transformers import AutoTokenizer, XLNetModel\n>>> import torch\n\n>>> tokenizer = AutoTokenizer.from_pretrained(\"xlnet-base-cased\")\n>>> model = XLNetModel.from_pretrained(\"xlnet-base-cased\")\n\n>>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"pt\")\n>>> outputs = model(**inputs)\n\n>>> last_hidden_states = outputs.last_hidden_state
config (XLNetConfig) — Model configuration class with all the parameters of the model.\nInitializing with a config file does not load the weights associated with the model, only the\nconfiguration. Check out the from_pretrained() method to load the model weights.
XLNet Model with a language modeling head on top (linear layer with weights tied to the input embeddings).
This model inherits from PreTrainedModel. Check the superclass documentation for the generic methods the\nlibrary implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\netc.)
This model is also a PyTorch torch.nn.Module subclass.\nUse it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage\nand behavior.
mems (List[torch.FloatTensor] of length config.n_layers) —\nContains pre-computed hidden-states (see mems output below) . Can be used to speed up sequential\ndecoding. The token ids which have their past given to this model should not be passed as input_ids as\nthey have already been computed.\n
use_mems has to be set to True to make use of mems.
perm_mask (torch.FloatTensor of shape (batch_size, sequence_length, sequence_length), optional) —\nMask to indicate the attention pattern for each input token with values selected in [0, 1]:\n
\n
if perm_mask[k, i, j] = 0, i attend to j in batch k;
\n
if perm_mask[k, i, j] = 1, i does not attend to j in batch k.
\n
\n
If not set, each token attends to all the others (full bidirectional attention). Only used during\npretraining (to define factorization order) or for sequential decoding (generation).
target_mapping (torch.FloatTensor of shape (batch_size, num_predict, sequence_length), optional) —\nMask to indicate the output tokens to use. If target_mapping[k, i, j] = 1, the i-th predict in batch k is\non the j-th token. Only used during pretraining for partial prediction or for sequential decoding\n(generation).
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) —\nSegment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:\n
input_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) —\nMask to avoid performing attention on padding token indices. Negative of attention_mask, i.e. with 0 for\nreal tokens and 1 for padding which is kept for compatibility with the original code base.\n
Mask values selected in [0, 1]:
\n
\n
1 for tokens that are masked,
\n
0 for tokens that are not masked.
\n
\n
You can only uses one of input_mask and attention_mask.
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) —\nMask to nullify selected heads of the self-attention modules. Mask values selected in [0, 1]:\n
\n
1 indicates the head is not masked,
\n
0 indicates the head is masked.
\n
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) —\nOptionally, instead of passing input_ids you can choose to directly pass an embedded representation. This\nis useful if you want more control over how to convert input_ids indices into associated vectors than the\nmodel’s internal embedding lookup matrix.
output_attentions (bool, optional) —\nWhether or not to return the attentions tensors of all attention layers. See attentions under returned\ntensors for more detail.
output_hidden_states (bool, optional) —\nWhether or not to return the hidden states of all layers. See hidden_states under returned tensors for\nmore detail.
return_dict (bool, optional) —\nWhether or not to return a ModelOutput instead of a plain tuple.
labels (torch.LongTensor of shape (batch_size, num_predict), optional) —\nLabels for masked language modeling. num_predict corresponds to target_mapping.shape[1]. If\ntarget_mapping is None, then num_predict corresponds to sequence_length.\n
The labels should correspond to the masked input words that should be predicted and depends on\ntarget_mapping. Note in order to perform standard auto-regressive language modeling a token has\nto be added to the input_ids (see the prepare_inputs_for_generation function and examples below)
\n
Indices are selected in [-100, 0, ..., config.vocab_size] All labels set to -100 are ignored, the loss\nis only computed for labels in [0, ..., config.vocab_size]
loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided)\nLanguage modeling loss (for next-token prediction).
\n
\n
\n
logits (torch.FloatTensor of shape (batch_size, num_predict, config.vocab_size)) — Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
\n
num_predict corresponds to target_mapping.shape[1]. If target_mapping is None, then num_predict\ncorresponds to sequence_length.
\n
\n
\n
mems (List[torch.FloatTensor] of length config.n_layers) — Contains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
\n
\n
\n
hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings + one for the output of each layer) of\nshape (batch_size, sequence_length, hidden_size).
\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
\n
\n
\n
attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).
\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
\n
\n
\n
The XLNetLMHeadModel forward method, overrides the __call__ special method.
Although the recipe for forward pass needs to be defined within this function, one should call the Module\ninstance afterwards instead of this since the former takes care of running the pre and post processing steps while\nthe latter silently ignores them.
Examples:
>>> from transformers import AutoTokenizer, XLNetLMHeadModel\n>>> import torch\n\n>>> tokenizer = AutoTokenizer.from_pretrained(\"xlnet-large-cased\")\n>>> model = XLNetLMHeadModel.from_pretrained(\"xlnet-large-cased\")\n\n>>> # We show how to setup inputs to predict a next token using a bi-directional context.\n>>> input_ids = torch.tensor(\n... tokenizer.encode(\"Hello, my dog is very <mask>\", add_special_tokens=False)\n... ).unsqueeze(\n... 0\n... ) # We will predict the masked token\n>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)\n>>> perm_mask[:, :, -1] = 1.0# Previous tokens don't see last token\n>>> target_mapping = torch.zeros(\n... (1, 1, input_ids.shape[1]), dtype=torch.float\n... ) # Shape [1, 1, seq_length] => let's predict one token\n>>> target_mapping[\n... 0, 0, -1\n... ] = 1.0# Our first (and only) prediction will be the last token of the sequence (the masked token)\n\n>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping)\n>>> next_token_logits = outputs[\n... 0\n... ] # Output has shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]\n\n>>> # The same way can the XLNetLMHeadModel be used to be trained by standard auto-regressive language modeling.\n>>> input_ids = torch.tensor(\n... tokenizer.encode(\"Hello, my dog is very <mask>\", add_special_tokens=False)\n... ).unsqueeze(\n... 0\n... ) # We will predict the masked token\n>>> labels = torch.tensor(tokenizer.encode(\"cute\", add_special_tokens=False)).unsqueeze(0)\n>>> assert labels.shape[0] == 1, \"only one word will be predicted\"\n>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)\n>>> perm_mask[\n... :, :, -1\n... ] = 1.0# Previous tokens don't see last token as is done in standard auto-regressive lm training\n>>> target_mapping = torch.zeros(\n... (1, 1, input_ids.shape[1]), dtype=torch.float\n... ) # Shape [1, 1, seq_length] => let's predict one token\n>>> target_mapping[\n... 0, 0, -1\n... ] = 1.0# Our first (and only) prediction will be the last token of the sequence (the masked token)\n\n>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping, labels=labels)\n>>> loss = outputs.loss\n>>> next_token_logits = (\n... outputs.logits\n... ) # Logits have shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]
config (XLNetConfig) — Model configuration class with all the parameters of the model.\nInitializing with a config file does not load the weights associated with the model, only the\nconfiguration. Check out the from_pretrained() method to load the model weights.
XLNet Model with a sequence classification/regression head on top (a linear layer on top of the pooled output) e.g.\nfor GLUE tasks.
This model inherits from PreTrainedModel. Check the superclass documentation for the generic methods the\nlibrary implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\netc.)
This model is also a PyTorch torch.nn.Module subclass.\nUse it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage\nand behavior.
mems (List[torch.FloatTensor] of length config.n_layers) —\nContains pre-computed hidden-states (see mems output below) . Can be used to speed up sequential\ndecoding. The token ids which have their past given to this model should not be passed as input_ids as\nthey have already been computed.\n
use_mems has to be set to True to make use of mems.
perm_mask (torch.FloatTensor of shape (batch_size, sequence_length, sequence_length), optional) —\nMask to indicate the attention pattern for each input token with values selected in [0, 1]:\n
\n
if perm_mask[k, i, j] = 0, i attend to j in batch k;
\n
if perm_mask[k, i, j] = 1, i does not attend to j in batch k.
\n
\n
If not set, each token attends to all the others (full bidirectional attention). Only used during\npretraining (to define factorization order) or for sequential decoding (generation).
target_mapping (torch.FloatTensor of shape (batch_size, num_predict, sequence_length), optional) —\nMask to indicate the output tokens to use. If target_mapping[k, i, j] = 1, the i-th predict in batch k is\non the j-th token. Only used during pretraining for partial prediction or for sequential decoding\n(generation).
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) —\nSegment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:\n
input_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) —\nMask to avoid performing attention on padding token indices. Negative of attention_mask, i.e. with 0 for\nreal tokens and 1 for padding which is kept for compatibility with the original code base.\n
Mask values selected in [0, 1]:
\n
\n
1 for tokens that are masked,
\n
0 for tokens that are not masked.
\n
\n
You can only uses one of input_mask and attention_mask.
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) —\nMask to nullify selected heads of the self-attention modules. Mask values selected in [0, 1]:\n
\n
1 indicates the head is not masked,
\n
0 indicates the head is masked.
\n
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) —\nOptionally, instead of passing input_ids you can choose to directly pass an embedded representation. This\nis useful if you want more control over how to convert input_ids indices into associated vectors than the\nmodel’s internal embedding lookup matrix.
output_attentions (bool, optional) —\nWhether or not to return the attentions tensors of all attention layers. See attentions under returned\ntensors for more detail.
output_hidden_states (bool, optional) —\nWhether or not to return the hidden states of all layers. See hidden_states under returned tensors for\nmore detail.
return_dict (bool, optional) —\nWhether or not to return a ModelOutput instead of a plain tuple.
labels (torch.LongTensor of shape (batch_size,), optional) —\nLabels for computing the sequence classification/regression loss. Indices should be in [0, ..., config.num_labels - 1]. If config.num_labels == 1 a regression loss is computed (Mean-Square loss), If\nconfig.num_labels > 1 a classification loss is computed (Cross-Entropy).
loss (torch.FloatTensor of shape (1,), optional, returned when label is provided) — Classification (or regression if config.num_labels==1) loss.
\n
\n
\n
logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — Classification (or regression if config.num_labels==1) scores (before SoftMax).
\n
\n
\n
mems (List[torch.FloatTensor] of length config.n_layers) — Contains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
\n
\n
\n
hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings + one for the output of each layer) of\nshape (batch_size, sequence_length, hidden_size).
\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
\n
\n
\n
attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).
\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
Although the recipe for forward pass needs to be defined within this function, one should call the Module\ninstance afterwards instead of this since the former takes care of running the pre and post processing steps while\nthe latter silently ignores them.
Example of single-label classification:
>>> import torch\n>>> from transformers import AutoTokenizer, XLNetForSequenceClassification\n\n>>> tokenizer = AutoTokenizer.from_pretrained(\"xlnet-base-cased\")\n>>> model = XLNetForSequenceClassification.from_pretrained(\"xlnet-base-cased\")\n\n>>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"pt\")\n\n>>> with torch.no_grad():\n... logits = model(**inputs).logits\n\n>>> predicted_class_id = logits.argmax().item()\n\n>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`\n>>> num_labels = len(model.config.id2label)\n>>> model = XLNetForSequenceClassification.from_pretrained(\"xlnet-base-cased\", num_labels=num_labels)\n\n>>> labels = torch.tensor([1])\n>>> loss = model(**inputs, labels=labels).loss
Example of multi-label classification:
>>> import torch\n>>> from transformers import AutoTokenizer, XLNetForSequenceClassification\n\n>>> tokenizer = AutoTokenizer.from_pretrained(\"xlnet-base-cased\")\n>>> model = XLNetForSequenceClassification.from_pretrained(\"xlnet-base-cased\", problem_type=\"multi_label_classification\")\n\n>>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"pt\")\n\n>>> with torch.no_grad():\n... logits = model(**inputs).logits\n\n>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]\n\n>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`\n>>> num_labels = len(model.config.id2label)\n>>> model = XLNetForSequenceClassification.from_pretrained(\n... \"xlnet-base-cased\", num_labels=num_labels, problem_type=\"multi_label_classification\"\n... )\n\n>>> labels = torch.sum(\n... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1\n... ).to(torch.float)\n>>> loss = model(**inputs, labels=labels).loss
config (XLNetConfig) — Model configuration class with all the parameters of the model.\nInitializing with a config file does not load the weights associated with the model, only the\nconfiguration. Check out the from_pretrained() method to load the model weights.
XLNet Model with a multiple choice classification head on top (a linear layer on top of the pooled output and a\nsoftmax) e.g. for RACE/SWAG tasks.
This model inherits from PreTrainedModel. Check the superclass documentation for the generic methods the\nlibrary implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\netc.)
This model is also a PyTorch torch.nn.Module subclass.\nUse it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage\nand behavior.
mems (List[torch.FloatTensor] of length config.n_layers) —\nContains pre-computed hidden-states (see mems output below) . Can be used to speed up sequential\ndecoding. The token ids which have their past given to this model should not be passed as input_ids as\nthey have already been computed.\n
use_mems has to be set to True to make use of mems.
perm_mask (torch.FloatTensor of shape (batch_size, sequence_length, sequence_length), optional) —\nMask to indicate the attention pattern for each input token with values selected in [0, 1]:\n
\n
if perm_mask[k, i, j] = 0, i attend to j in batch k;
\n
if perm_mask[k, i, j] = 1, i does not attend to j in batch k.
\n
\n
If not set, each token attends to all the others (full bidirectional attention). Only used during\npretraining (to define factorization order) or for sequential decoding (generation).
target_mapping (torch.FloatTensor of shape (batch_size, num_predict, sequence_length), optional) —\nMask to indicate the output tokens to use. If target_mapping[k, i, j] = 1, the i-th predict in batch k is\non the j-th token. Only used during pretraining for partial prediction or for sequential decoding\n(generation).
token_type_ids (torch.LongTensor of shape (batch_size, num_choices, sequence_length), optional) —\nSegment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:\n
input_mask (torch.FloatTensor of shape batch_size, num_choices, sequence_length, optional) —\nMask to avoid performing attention on padding token indices. Negative of attention_mask, i.e. with 0 for\nreal tokens and 1 for padding which is kept for compatibility with the original code base.\n
Mask values selected in [0, 1]:
\n
\n
1 for tokens that are masked,
\n
0 for tokens that are not masked.
\n
\n
You can only uses one of input_mask and attention_mask.
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) —\nMask to nullify selected heads of the self-attention modules. Mask values selected in [0, 1]:\n
\n
1 indicates the head is not masked,
\n
0 indicates the head is masked.
\n
inputs_embeds (torch.FloatTensor of shape (batch_size, num_choices, sequence_length, hidden_size), optional) —\nOptionally, instead of passing input_ids you can choose to directly pass an embedded representation. This\nis useful if you want more control over how to convert input_ids indices into associated vectors than the\nmodel’s internal embedding lookup matrix.
output_attentions (bool, optional) —\nWhether or not to return the attentions tensors of all attention layers. See attentions under returned\ntensors for more detail.
output_hidden_states (bool, optional) —\nWhether or not to return the hidden states of all layers. See hidden_states under returned tensors for\nmore detail.
return_dict (bool, optional) —\nWhether or not to return a ModelOutput instead of a plain tuple.
labels (torch.LongTensor of shape (batch_size,), optional) —\nLabels for computing the multiple choice classification loss. Indices should be in [0, ..., num_choices-1] where num_choices is the size of the second dimension of the input tensors. (See\ninput_ids above)
loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — Classification loss.
\n
\n
\n
logits (torch.FloatTensor of shape (batch_size, num_choices)) — num_choices is the second dimension of the input tensors. (see input_ids above).
\n
Classification scores (before SoftMax).
\n
\n
\n
mems (List[torch.FloatTensor] of length config.n_layers) — Contains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
\n
\n
\n
hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings + one for the output of each layer) of\nshape (batch_size, sequence_length, hidden_size).
\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
\n
\n
\n
attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).
\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
Although the recipe for forward pass needs to be defined within this function, one should call the Module\ninstance afterwards instead of this since the former takes care of running the pre and post processing steps while\nthe latter silently ignores them.
Example:
>>> from transformers import AutoTokenizer, XLNetForMultipleChoice\n>>> import torch\n\n>>> tokenizer = AutoTokenizer.from_pretrained(\"xlnet-base-cased\")\n>>> model = XLNetForMultipleChoice.from_pretrained(\"xlnet-base-cased\")\n\n>>> prompt = \"In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced.\"\n>>> choice0 = \"It is eaten with a fork and a knife.\"\n>>> choice1 = \"It is eaten while held in the hand.\"\n>>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1\n\n>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors=\"pt\", padding=True)\n>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels) # batch size is 1\n\n>>> # the linear classifier still needs to be trained\n>>> loss = outputs.loss\n>>> logits = outputs.logits
config (XLNetConfig) — Model configuration class with all the parameters of the model.\nInitializing with a config file does not load the weights associated with the model, only the\nconfiguration. Check out the from_pretrained() method to load the model weights.
XLNet Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for\nNamed-Entity-Recognition (NER) tasks.
This model inherits from PreTrainedModel. Check the superclass documentation for the generic methods the\nlibrary implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\netc.)
This model is also a PyTorch torch.nn.Module subclass.\nUse it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage\nand behavior.
mems (List[torch.FloatTensor] of length config.n_layers) —\nContains pre-computed hidden-states (see mems output below) . Can be used to speed up sequential\ndecoding. The token ids which have their past given to this model should not be passed as input_ids as\nthey have already been computed.\n
use_mems has to be set to True to make use of mems.
perm_mask (torch.FloatTensor of shape (batch_size, sequence_length, sequence_length), optional) —\nMask to indicate the attention pattern for each input token with values selected in [0, 1]:\n
\n
if perm_mask[k, i, j] = 0, i attend to j in batch k;
\n
if perm_mask[k, i, j] = 1, i does not attend to j in batch k.
\n
\n
If not set, each token attends to all the others (full bidirectional attention). Only used during\npretraining (to define factorization order) or for sequential decoding (generation).
target_mapping (torch.FloatTensor of shape (batch_size, num_predict, sequence_length), optional) —\nMask to indicate the output tokens to use. If target_mapping[k, i, j] = 1, the i-th predict in batch k is\non the j-th token. Only used during pretraining for partial prediction or for sequential decoding\n(generation).
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) —\nSegment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:\n
input_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) —\nMask to avoid performing attention on padding token indices. Negative of attention_mask, i.e. with 0 for\nreal tokens and 1 for padding which is kept for compatibility with the original code base.\n
Mask values selected in [0, 1]:
\n
\n
1 for tokens that are masked,
\n
0 for tokens that are not masked.
\n
\n
You can only uses one of input_mask and attention_mask.
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) —\nMask to nullify selected heads of the self-attention modules. Mask values selected in [0, 1]:\n
\n
1 indicates the head is not masked,
\n
0 indicates the head is masked.
\n
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) —\nOptionally, instead of passing input_ids you can choose to directly pass an embedded representation. This\nis useful if you want more control over how to convert input_ids indices into associated vectors than the\nmodel’s internal embedding lookup matrix.
output_attentions (bool, optional) —\nWhether or not to return the attentions tensors of all attention layers. See attentions under returned\ntensors for more detail.
output_hidden_states (bool, optional) —\nWhether or not to return the hidden states of all layers. See hidden_states under returned tensors for\nmore detail.
return_dict (bool, optional) —\nWhether or not to return a ModelOutput instead of a plain tuple.
labels (torch.LongTensor of shape (batch_size,), optional) —\nLabels for computing the multiple choice classification loss. Indices should be in [0, ..., num_choices]\nwhere num_choices is the size of the second dimension of the input tensors. (see input_ids above)
mems (List[torch.FloatTensor] of length config.n_layers) — Contains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
\n
\n
\n
hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings + one for the output of each layer) of\nshape (batch_size, sequence_length, hidden_size).
\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
\n
\n
\n
attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).
\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
Although the recipe for forward pass needs to be defined within this function, one should call the Module\ninstance afterwards instead of this since the former takes care of running the pre and post processing steps while\nthe latter silently ignores them.
Example:
>>> from transformers import AutoTokenizer, XLNetForTokenClassification\n>>> import torch\n\n>>> tokenizer = AutoTokenizer.from_pretrained(\"xlnet-base-cased\")\n>>> model = XLNetForTokenClassification.from_pretrained(\"xlnet-base-cased\")\n\n>>> inputs = tokenizer(\n... \"HuggingFace is a company based in Paris and New York\", add_special_tokens=False, return_tensors=\"pt\"\n... )\n\n>>> with torch.no_grad():\n... logits = model(**inputs).logits\n\n>>> predicted_token_class_ids = logits.argmax(-1)\n\n>>> # Note that tokens are classified rather then input words which means that\n>>> # there might be more predicted token classes than words.\n>>> # Multiple token classes might account for the same word\n>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]\n\n>>> labels = predicted_token_class_ids\n>>> loss = model(**inputs, labels=labels).loss
config (XLNetConfig) — Model configuration class with all the parameters of the model.\nInitializing with a config file does not load the weights associated with the model, only the\nconfiguration. Check out the from_pretrained() method to load the model weights.
XLNet Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear\nlayers on top of the hidden-states output to compute span start logits and span end logits).
This model inherits from PreTrainedModel. Check the superclass documentation for the generic methods the\nlibrary implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\netc.)
This model is also a PyTorch torch.nn.Module subclass.\nUse it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage\nand behavior.
mems (List[torch.FloatTensor] of length config.n_layers) —\nContains pre-computed hidden-states (see mems output below) . Can be used to speed up sequential\ndecoding. The token ids which have their past given to this model should not be passed as input_ids as\nthey have already been computed.\n
use_mems has to be set to True to make use of mems.
perm_mask (torch.FloatTensor of shape (batch_size, sequence_length, sequence_length), optional) —\nMask to indicate the attention pattern for each input token with values selected in [0, 1]:\n
\n
if perm_mask[k, i, j] = 0, i attend to j in batch k;
\n
if perm_mask[k, i, j] = 1, i does not attend to j in batch k.
\n
\n
If not set, each token attends to all the others (full bidirectional attention). Only used during\npretraining (to define factorization order) or for sequential decoding (generation).
target_mapping (torch.FloatTensor of shape (batch_size, num_predict, sequence_length), optional) —\nMask to indicate the output tokens to use. If target_mapping[k, i, j] = 1, the i-th predict in batch k is\non the j-th token. Only used during pretraining for partial prediction or for sequential decoding\n(generation).
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) —\nSegment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:\n
input_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) —\nMask to avoid performing attention on padding token indices. Negative of attention_mask, i.e. with 0 for\nreal tokens and 1 for padding which is kept for compatibility with the original code base.\n
Mask values selected in [0, 1]:
\n
\n
1 for tokens that are masked,
\n
0 for tokens that are not masked.
\n
\n
You can only uses one of input_mask and attention_mask.
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) —\nMask to nullify selected heads of the self-attention modules. Mask values selected in [0, 1]:\n
\n
1 indicates the head is not masked,
\n
0 indicates the head is masked.
\n
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) —\nOptionally, instead of passing input_ids you can choose to directly pass an embedded representation. This\nis useful if you want more control over how to convert input_ids indices into associated vectors than the\nmodel’s internal embedding lookup matrix.
output_attentions (bool, optional) —\nWhether or not to return the attentions tensors of all attention layers. See attentions under returned\ntensors for more detail.
output_hidden_states (bool, optional) —\nWhether or not to return the hidden states of all layers. See hidden_states under returned tensors for\nmore detail.
return_dict (bool, optional) —\nWhether or not to return a ModelOutput instead of a plain tuple.
start_positions (torch.LongTensor of shape (batch_size,), optional) —\nLabels for position (index) of the start of the labelled span for computing the token classification loss.\nPositions are clamped to the length of the sequence (sequence_length). Position outside of the sequence\nare not taken into account for computing the loss.
end_positions (torch.LongTensor of shape (batch_size,), optional) —\nLabels for position (index) of the end of the labelled span for computing the token classification loss.\nPositions are clamped to the length of the sequence (sequence_length). Position outside of the sequence\nare not taken into account for computing the loss.
loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — Total span extraction loss is the sum of a Cross-Entropy for the start and end positions.
mems (List[torch.FloatTensor] of length config.n_layers) — Contains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
\n
\n
\n
hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings + one for the output of each layer) of\nshape (batch_size, sequence_length, hidden_size).
\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
\n
\n
\n
attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).
\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
Although the recipe for forward pass needs to be defined within this function, one should call the Module\ninstance afterwards instead of this since the former takes care of running the pre and post processing steps while\nthe latter silently ignores them.
Example:
>>> from transformers import AutoTokenizer, XLNetForQuestionAnsweringSimple\n>>> import torch\n\n>>> tokenizer = AutoTokenizer.from_pretrained(\"xlnet-base-cased\")\n>>> model = XLNetForQuestionAnsweringSimple.from_pretrained(\"xlnet-base-cased\")\n\n>>> question, text = \"Who was Jim Henson?\", \"Jim Henson was a nice puppet\"\n\n>>> inputs = tokenizer(question, text, return_tensors=\"pt\")\n>>> with torch.no_grad():\n... outputs = model(**inputs)\n\n>>> answer_start_index = outputs.start_logits.argmax()\n>>> answer_end_index = outputs.end_logits.argmax()\n\n>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]\n\n>>> # target is \"nice puppet\"\n>>> target_start_index = torch.tensor([14])\n>>> target_end_index = torch.tensor([15])\n\n>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)\n>>> loss = outputs.loss
config (XLNetConfig) — Model configuration class with all the parameters of the model.\nInitializing with a config file does not load the weights associated with the model, only the\nconfiguration. Check out the from_pretrained() method to load the model weights.
XLNet Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear\nlayers on top of the hidden-states output to compute span start logits and span end logits).
This model inherits from PreTrainedModel. Check the superclass documentation for the generic methods the\nlibrary implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\netc.)
This model is also a PyTorch torch.nn.Module subclass.\nUse it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage\nand behavior.
mems (List[torch.FloatTensor] of length config.n_layers) —\nContains pre-computed hidden-states (see mems output below) . Can be used to speed up sequential\ndecoding. The token ids which have their past given to this model should not be passed as input_ids as\nthey have already been computed.\n
use_mems has to be set to True to make use of mems.
perm_mask (torch.FloatTensor of shape (batch_size, sequence_length, sequence_length), optional) —\nMask to indicate the attention pattern for each input token with values selected in [0, 1]:\n
\n
if perm_mask[k, i, j] = 0, i attend to j in batch k;
\n
if perm_mask[k, i, j] = 1, i does not attend to j in batch k.
\n
\n
If not set, each token attends to all the others (full bidirectional attention). Only used during\npretraining (to define factorization order) or for sequential decoding (generation).
target_mapping (torch.FloatTensor of shape (batch_size, num_predict, sequence_length), optional) —\nMask to indicate the output tokens to use. If target_mapping[k, i, j] = 1, the i-th predict in batch k is\non the j-th token. Only used during pretraining for partial prediction or for sequential decoding\n(generation).
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) —\nSegment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:\n
input_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) —\nMask to avoid performing attention on padding token indices. Negative of attention_mask, i.e. with 0 for\nreal tokens and 1 for padding which is kept for compatibility with the original code base.\n
Mask values selected in [0, 1]:
\n
\n
1 for tokens that are masked,
\n
0 for tokens that are not masked.
\n
\n
You can only uses one of input_mask and attention_mask.
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) —\nMask to nullify selected heads of the self-attention modules. Mask values selected in [0, 1]:\n
\n
1 indicates the head is not masked,
\n
0 indicates the head is masked.
\n
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) —\nOptionally, instead of passing input_ids you can choose to directly pass an embedded representation. This\nis useful if you want more control over how to convert input_ids indices into associated vectors than the\nmodel’s internal embedding lookup matrix.
output_attentions (bool, optional) —\nWhether or not to return the attentions tensors of all attention layers. See attentions under returned\ntensors for more detail.
output_hidden_states (bool, optional) —\nWhether or not to return the hidden states of all layers. See hidden_states under returned tensors for\nmore detail.
return_dict (bool, optional) —\nWhether or not to return a ModelOutput instead of a plain tuple.
start_positions (torch.LongTensor of shape (batch_size,), optional) —\nLabels for position (index) of the start of the labelled span for computing the token classification loss.\nPositions are clamped to the length of the sequence (sequence_length). Position outside of the sequence\nare not taken into account for computing the loss.
end_positions (torch.LongTensor of shape (batch_size,), optional) —\nLabels for position (index) of the end of the labelled span for computing the token classification loss.\nPositions are clamped to the length of the sequence (sequence_length). Position outside of the sequence\nare not taken into account for computing the loss.
is_impossible (torch.LongTensor of shape (batch_size,), optional) —\nLabels whether a question has an answer or no answer (SQuAD 2.0)
cls_index (torch.LongTensor of shape (batch_size,), optional) —\nLabels for position (index) of the classification token to use as input for computing plausibility of the\nanswer.
p_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) —\nOptional mask of tokens which can’t be in answers (e.g. [CLS], [PAD], …). 1.0 means token should be\nmasked. 0.0 mean token is not masked.
loss (torch.FloatTensor of shape (1,), optional, returned if both start_positions and end_positions are provided) — Classification loss as the sum of start token, end token (and is_impossible if provided) classification\nlosses.
\n
\n
\n
start_top_log_probs (torch.FloatTensor of shape (batch_size, config.start_n_top), optional, returned if start_positions or end_positions is not provided) — Log probabilities for the top config.start_n_top start token possibilities (beam-search).
\n
\n
\n
start_top_index (torch.LongTensor of shape (batch_size, config.start_n_top), optional, returned if start_positions or end_positions is not provided) — Indices for the top config.start_n_top start token possibilities (beam-search).
\n
\n
\n
end_top_log_probs (torch.FloatTensor of shape (batch_size, config.start_n_top * config.end_n_top), optional, returned if start_positions or end_positions is not provided) — Log probabilities for the top config.start_n_top * config.end_n_top end token possibilities\n(beam-search).
\n
\n
\n
end_top_index (torch.LongTensor of shape (batch_size, config.start_n_top * config.end_n_top), optional, returned if start_positions or end_positions is not provided) — Indices for the top config.start_n_top * config.end_n_top end token possibilities (beam-search).
\n
\n
\n
cls_logits (torch.FloatTensor of shape (batch_size,), optional, returned if start_positions or end_positions is not provided) — Log probabilities for the is_impossible label of the answers.
\n
\n
\n
mems (List[torch.FloatTensor] of length config.n_layers) — Contains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
\n
\n
\n
hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings + one for the output of each layer) of\nshape (batch_size, sequence_length, hidden_size).
\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
\n
\n
\n
attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).
\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
Although the recipe for forward pass needs to be defined within this function, one should call the Module\ninstance afterwards instead of this since the former takes care of running the pre and post processing steps while\nthe latter silently ignores them.
Example:
>>> from transformers import AutoTokenizer, XLNetForQuestionAnswering\n>>> import torch\n\n>>> tokenizer = AutoTokenizer.from_pretrained(\"xlnet-base-cased\")\n>>> model = XLNetForQuestionAnswering.from_pretrained(\"xlnet-base-cased\")\n\n>>> input_ids = torch.tensor(tokenizer.encode(\"Hello, my dog is cute\", add_special_tokens=True)).unsqueeze(\n... 0\n... ) # Batch size 1\n>>> start_positions = torch.tensor([1])\n>>> end_positions = torch.tensor([3])\n>>> outputs = model(input_ids, start_positions=start_positions, end_positions=end_positions)\n\n>>> loss = outputs.loss
config (XLNetConfig) — Model configuration class with all the parameters of the model.\nInitializing with a config file does not load the weights associated with the model, only the\nconfiguration. Check out the from_pretrained() method to load the model weights.
The bare XLNet Model transformer outputting raw hidden-states without any specific head on top.
This model inherits from TFPreTrainedModel. Check the superclass documentation for the generic methods the\nlibrary implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\netc.)
This model is also a tf.keras.Model subclass. Use it\nas a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and\nbehavior.
TensorFlow models and layers in transformers accept two formats as input:
having all inputs as keyword arguments (like PyTorch models), or
having all inputs as a list, tuple or dict in the first positional argument.
The reason the second format is supported is that Keras methods prefer this format when passing inputs to models\nand layers. Because of this support, when using methods like model.fit() things should “just work” for you - just\npass your inputs and labels in any format that model.fit() supports! If, however, you want to use the second\nformat outside of Keras methods like fit() and predict(), such as when creating your own layers or models with\nthe Keras Functional API, there are three possibilities you can use to gather all the input Tensors in the first\npositional argument:
a single Tensor with input_ids only and nothing else: model(input_ids)
a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:\nmodel([input_ids, attention_mask]) or model([input_ids, attention_mask, token_type_ids])
a dictionary with one or several input Tensors associated to the input names given in the docstring:\nmodel({\"input_ids\": input_ids, \"token_type_ids\": token_type_ids})
Note that when creating models and layers with\nsubclassing then you don’t need to worry\nabout any of this, as you can just pass inputs like you would to any other Python function!
mems (List[torch.FloatTensor] of length config.n_layers) —\nContains pre-computed hidden-states (see mems output below) . Can be used to speed up sequential\ndecoding. The token ids which have their past given to this model should not be passed as input_ids as\nthey have already been computed.\n
use_mems has to be set to True to make use of mems.
perm_mask (torch.FloatTensor of shape (batch_size, sequence_length, sequence_length), optional) —\nMask to indicate the attention pattern for each input token with values selected in [0, 1]:\n
\n
if perm_mask[k, i, j] = 0, i attend to j in batch k;
\n
if perm_mask[k, i, j] = 1, i does not attend to j in batch k.
\n
\n
If not set, each token attends to all the others (full bidirectional attention). Only used during\npretraining (to define factorization order) or for sequential decoding (generation).
target_mapping (torch.FloatTensor of shape (batch_size, num_predict, sequence_length), optional) —\nMask to indicate the output tokens to use. If target_mapping[k, i, j] = 1, the i-th predict in batch k is\non the j-th token. Only used during pretraining for partial prediction or for sequential decoding\n(generation).
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) —\nSegment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:\n
input_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) —\nMask to avoid performing attention on padding token indices. Negative of attention_mask, i.e. with 0 for\nreal tokens and 1 for padding which is kept for compatibility with the original code base.\n
Mask values selected in [0, 1]:
\n
\n
1 for tokens that are masked,
\n
0 for tokens that are not masked.
\n
\n
You can only uses one of input_mask and attention_mask.
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) —\nMask to nullify selected heads of the self-attention modules. Mask values selected in [0, 1]:\n
\n
1 indicates the head is not masked,
\n
0 indicates the head is masked.
\n
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) —\nOptionally, instead of passing input_ids you can choose to directly pass an embedded representation. This\nis useful if you want more control over how to convert input_ids indices into associated vectors than the\nmodel’s internal embedding lookup matrix.
output_attentions (bool, optional) —\nWhether or not to return the attentions tensors of all attention layers. See attentions under returned\ntensors for more detail.
output_hidden_states (bool, optional) —\nWhether or not to return the hidden states of all layers. See hidden_states under returned tensors for\nmore detail.
return_dict (bool, optional) —\nWhether or not to return a ModelOutput instead of a plain tuple.
last_hidden_state (tf.Tensor of shape (batch_size, num_predict, hidden_size)) — Sequence of hidden-states at the last layer of the model.
\n
num_predict corresponds to target_mapping.shape[1]. If target_mapping is None, then num_predict\ncorresponds to sequence_length.
\n
\n
\n
mems (List[tf.Tensor] of length config.n_layers) — Contains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
\n
\n
\n
hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape\n(batch_size, sequence_length, hidden_size).
\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
\n
\n
\n
attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).
\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
\n
\n
\n
The TFXLNetModel forward method, overrides the __call__ special method.
Although the recipe for forward pass needs to be defined within this function, one should call the Module\ninstance afterwards instead of this since the former takes care of running the pre and post processing steps while\nthe latter silently ignores them.
Example:
>>> from transformers import AutoTokenizer, TFXLNetModel\n>>> import tensorflow as tf\n\n>>> tokenizer = AutoTokenizer.from_pretrained(\"xlnet-base-cased\")\n>>> model = TFXLNetModel.from_pretrained(\"xlnet-base-cased\")\n\n>>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"tf\")\n>>> outputs = model(inputs)\n\n>>> last_hidden_states = outputs.last_hidden_state
config (XLNetConfig) — Model configuration class with all the parameters of the model.\nInitializing with a config file does not load the weights associated with the model, only the\nconfiguration. Check out the from_pretrained() method to load the model weights.
XLNet Model with a language modeling head on top (linear layer with weights tied to the input embeddings).
This model inherits from TFPreTrainedModel. Check the superclass documentation for the generic methods the\nlibrary implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\netc.)
This model is also a tf.keras.Model subclass. Use it\nas a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and\nbehavior.
TensorFlow models and layers in transformers accept two formats as input:
having all inputs as keyword arguments (like PyTorch models), or
having all inputs as a list, tuple or dict in the first positional argument.
The reason the second format is supported is that Keras methods prefer this format when passing inputs to models\nand layers. Because of this support, when using methods like model.fit() things should “just work” for you - just\npass your inputs and labels in any format that model.fit() supports! If, however, you want to use the second\nformat outside of Keras methods like fit() and predict(), such as when creating your own layers or models with\nthe Keras Functional API, there are three possibilities you can use to gather all the input Tensors in the first\npositional argument:
a single Tensor with input_ids only and nothing else: model(input_ids)
a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:\nmodel([input_ids, attention_mask]) or model([input_ids, attention_mask, token_type_ids])
a dictionary with one or several input Tensors associated to the input names given in the docstring:\nmodel({\"input_ids\": input_ids, \"token_type_ids\": token_type_ids})
Note that when creating models and layers with\nsubclassing then you don’t need to worry\nabout any of this, as you can just pass inputs like you would to any other Python function!
mems (List[torch.FloatTensor] of length config.n_layers) —\nContains pre-computed hidden-states (see mems output below) . Can be used to speed up sequential\ndecoding. The token ids which have their past given to this model should not be passed as input_ids as\nthey have already been computed.\n
use_mems has to be set to True to make use of mems.
perm_mask (torch.FloatTensor of shape (batch_size, sequence_length, sequence_length), optional) —\nMask to indicate the attention pattern for each input token with values selected in [0, 1]:\n
\n
if perm_mask[k, i, j] = 0, i attend to j in batch k;
\n
if perm_mask[k, i, j] = 1, i does not attend to j in batch k.
\n
\n
If not set, each token attends to all the others (full bidirectional attention). Only used during\npretraining (to define factorization order) or for sequential decoding (generation).
target_mapping (torch.FloatTensor of shape (batch_size, num_predict, sequence_length), optional) —\nMask to indicate the output tokens to use. If target_mapping[k, i, j] = 1, the i-th predict in batch k is\non the j-th token. Only used during pretraining for partial prediction or for sequential decoding\n(generation).
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) —\nSegment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:\n
input_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) —\nMask to avoid performing attention on padding token indices. Negative of attention_mask, i.e. with 0 for\nreal tokens and 1 for padding which is kept for compatibility with the original code base.\n
Mask values selected in [0, 1]:
\n
\n
1 for tokens that are masked,
\n
0 for tokens that are not masked.
\n
\n
You can only uses one of input_mask and attention_mask.
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) —\nMask to nullify selected heads of the self-attention modules. Mask values selected in [0, 1]:\n
\n
1 indicates the head is not masked,
\n
0 indicates the head is masked.
\n
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) —\nOptionally, instead of passing input_ids you can choose to directly pass an embedded representation. This\nis useful if you want more control over how to convert input_ids indices into associated vectors than the\nmodel’s internal embedding lookup matrix.
output_attentions (bool, optional) —\nWhether or not to return the attentions tensors of all attention layers. See attentions under returned\ntensors for more detail.
output_hidden_states (bool, optional) —\nWhether or not to return the hidden states of all layers. See hidden_states under returned tensors for\nmore detail.
return_dict (bool, optional) —\nWhether or not to return a ModelOutput instead of a plain tuple.
labels (tf.Tensor of shape (batch_size, sequence_length), optional) —\nLabels for computing the cross entropy classification loss. Indices should be in [0, ..., config.vocab_size - 1].
loss (tf.Tensor of shape (1,), optional, returned when labels is provided)\nLanguage modeling loss (for next-token prediction).
\n
\n
\n
logits (tf.Tensor of shape (batch_size, num_predict, config.vocab_size)) — Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
\n
num_predict corresponds to target_mapping.shape[1]. If target_mapping is None, then num_predict\ncorresponds to sequence_length.
\n
\n
\n
mems (List[tf.Tensor] of length config.n_layers) — Contains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
\n
\n
\n
hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape\n(batch_size, sequence_length, hidden_size).
\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
\n
\n
\n
attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).
\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
\n
\n
\n
The TFXLNetLMHeadModel forward method, overrides the __call__ special method.
Although the recipe for forward pass needs to be defined within this function, one should call the Module\ninstance afterwards instead of this since the former takes care of running the pre and post processing steps while\nthe latter silently ignores them.
Examples:
>>> import tensorflow as tf\n>>> import numpy as np\n>>> from transformers import AutoTokenizer, TFXLNetLMHeadModel\n\n>>> tokenizer = AutoTokenizer.from_pretrained(\"xlnet-large-cased\")\n>>> model = TFXLNetLMHeadModel.from_pretrained(\"xlnet-large-cased\")\n\n>>> # We show how to setup inputs to predict a next token using a bi-directional context.\n>>> input_ids = tf.constant(tokenizer.encode(\"Hello, my dog is very <mask>\", add_special_tokens=True))[\n... None, :\n... ] # We will predict the masked token\n\n>>> perm_mask = np.zeros((1, input_ids.shape[1], input_ids.shape[1]))\n>>> perm_mask[:, :, -1] = 1.0# Previous tokens don't see last token\n\n>>> target_mapping = np.zeros(\n... (1, 1, input_ids.shape[1])\n... ) # Shape [1, 1, seq_length] => let's predict one token\n>>> target_mapping[\n... 0, 0, -1\n... ] = 1.0# Our first (and only) prediction will be the last token of the sequence (the masked token)\n\n>>> outputs = model(\n... input_ids,\n... perm_mask=tf.constant(perm_mask, dtype=tf.float32),\n... target_mapping=tf.constant(target_mapping, dtype=tf.float32),\n... )\n\n>>> next_token_logits = outputs[\n... 0\n... ] # Output has shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]
config (XLNetConfig) — Model configuration class with all the parameters of the model.\nInitializing with a config file does not load the weights associated with the model, only the\nconfiguration. Check out the from_pretrained() method to load the model weights.
XLNet Model with a sequence classification/regression head on top (a linear layer on top of the pooled output) e.g.\nfor GLUE tasks.
This model inherits from TFPreTrainedModel. Check the superclass documentation for the generic methods the\nlibrary implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\netc.)
This model is also a tf.keras.Model subclass. Use it\nas a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and\nbehavior.
TensorFlow models and layers in transformers accept two formats as input:
having all inputs as keyword arguments (like PyTorch models), or
having all inputs as a list, tuple or dict in the first positional argument.
The reason the second format is supported is that Keras methods prefer this format when passing inputs to models\nand layers. Because of this support, when using methods like model.fit() things should “just work” for you - just\npass your inputs and labels in any format that model.fit() supports! If, however, you want to use the second\nformat outside of Keras methods like fit() and predict(), such as when creating your own layers or models with\nthe Keras Functional API, there are three possibilities you can use to gather all the input Tensors in the first\npositional argument:
a single Tensor with input_ids only and nothing else: model(input_ids)
a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:\nmodel([input_ids, attention_mask]) or model([input_ids, attention_mask, token_type_ids])
a dictionary with one or several input Tensors associated to the input names given in the docstring:\nmodel({\"input_ids\": input_ids, \"token_type_ids\": token_type_ids})
Note that when creating models and layers with\nsubclassing then you don’t need to worry\nabout any of this, as you can just pass inputs like you would to any other Python function!
mems (List[torch.FloatTensor] of length config.n_layers) —\nContains pre-computed hidden-states (see mems output below) . Can be used to speed up sequential\ndecoding. The token ids which have their past given to this model should not be passed as input_ids as\nthey have already been computed.\n
use_mems has to be set to True to make use of mems.
perm_mask (torch.FloatTensor of shape (batch_size, sequence_length, sequence_length), optional) —\nMask to indicate the attention pattern for each input token with values selected in [0, 1]:\n
\n
if perm_mask[k, i, j] = 0, i attend to j in batch k;
\n
if perm_mask[k, i, j] = 1, i does not attend to j in batch k.
\n
\n
If not set, each token attends to all the others (full bidirectional attention). Only used during\npretraining (to define factorization order) or for sequential decoding (generation).
target_mapping (torch.FloatTensor of shape (batch_size, num_predict, sequence_length), optional) —\nMask to indicate the output tokens to use. If target_mapping[k, i, j] = 1, the i-th predict in batch k is\non the j-th token. Only used during pretraining for partial prediction or for sequential decoding\n(generation).
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) —\nSegment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:\n
input_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) —\nMask to avoid performing attention on padding token indices. Negative of attention_mask, i.e. with 0 for\nreal tokens and 1 for padding which is kept for compatibility with the original code base.\n
Mask values selected in [0, 1]:
\n
\n
1 for tokens that are masked,
\n
0 for tokens that are not masked.
\n
\n
You can only uses one of input_mask and attention_mask.
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) —\nMask to nullify selected heads of the self-attention modules. Mask values selected in [0, 1]:\n
\n
1 indicates the head is not masked,
\n
0 indicates the head is masked.
\n
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) —\nOptionally, instead of passing input_ids you can choose to directly pass an embedded representation. This\nis useful if you want more control over how to convert input_ids indices into associated vectors than the\nmodel’s internal embedding lookup matrix.
output_attentions (bool, optional) —\nWhether or not to return the attentions tensors of all attention layers. See attentions under returned\ntensors for more detail.
output_hidden_states (bool, optional) —\nWhether or not to return the hidden states of all layers. See hidden_states under returned tensors for\nmore detail.
return_dict (bool, optional) —\nWhether or not to return a ModelOutput instead of a plain tuple.
labels (tf.Tensor of shape (batch_size,), optional) —\nLabels for computing the sequence classification/regression loss. Indices should be in [0, ..., config.num_labels - 1]. If config.num_labels == 1 a regression loss is computed (Mean-Square loss), If\nconfig.num_labels > 1 a classification loss is computed (Cross-Entropy).
loss (tf.Tensor of shape (1,), optional, returned when label is provided) — Classification (or regression if config.num_labels==1) loss.
\n
\n
\n
logits (tf.Tensor of shape (batch_size, config.num_labels)) — Classification (or regression if config.num_labels==1) scores (before SoftMax).
\n
\n
\n
mems (List[tf.Tensor] of length config.n_layers) — Contains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
\n
\n
\n
hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape\n(batch_size, sequence_length, hidden_size).
\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
\n
\n
\n
attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).
\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
Although the recipe for forward pass needs to be defined within this function, one should call the Module\ninstance afterwards instead of this since the former takes care of running the pre and post processing steps while\nthe latter silently ignores them.
Example:
>>> from transformers import AutoTokenizer, TFXLNetForSequenceClassification\n>>> import tensorflow as tf\n\n>>> tokenizer = AutoTokenizer.from_pretrained(\"xlnet-base-cased\")\n>>> model = TFXLNetForSequenceClassification.from_pretrained(\"xlnet-base-cased\")\n\n>>> inputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"tf\")\n\n>>> logits = model(**inputs).logits\n\n>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`\n>>> num_labels = len(model.config.id2label)\n>>> model = TFXLNetForSequenceClassification.from_pretrained(\"xlnet-base-cased\", num_labels=num_labels)\n\n>>> labels = tf.constant(1)\n>>> loss = model(**inputs, labels=labels).loss
config (XLNetConfig) — Model configuration class with all the parameters of the model.\nInitializing with a config file does not load the weights associated with the model, only the\nconfiguration. Check out the from_pretrained() method to load the model weights.
XLNET Model with a multiple choice classification head on top (a linear layer on top of the pooled output and a\nsoftmax) e.g. for RocStories/SWAG tasks.
This model inherits from TFPreTrainedModel. Check the superclass documentation for the generic methods the\nlibrary implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\netc.)
This model is also a tf.keras.Model subclass. Use it\nas a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and\nbehavior.
TensorFlow models and layers in transformers accept two formats as input:
having all inputs as keyword arguments (like PyTorch models), or
having all inputs as a list, tuple or dict in the first positional argument.
The reason the second format is supported is that Keras methods prefer this format when passing inputs to models\nand layers. Because of this support, when using methods like model.fit() things should “just work” for you - just\npass your inputs and labels in any format that model.fit() supports! If, however, you want to use the second\nformat outside of Keras methods like fit() and predict(), such as when creating your own layers or models with\nthe Keras Functional API, there are three possibilities you can use to gather all the input Tensors in the first\npositional argument:
a single Tensor with input_ids only and nothing else: model(input_ids)
a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:\nmodel([input_ids, attention_mask]) or model([input_ids, attention_mask, token_type_ids])
a dictionary with one or several input Tensors associated to the input names given in the docstring:\nmodel({\"input_ids\": input_ids, \"token_type_ids\": token_type_ids})
Note that when creating models and layers with\nsubclassing then you don’t need to worry\nabout any of this, as you can just pass inputs like you would to any other Python function!
mems (List[torch.FloatTensor] of length config.n_layers) —\nContains pre-computed hidden-states (see mems output below) . Can be used to speed up sequential\ndecoding. The token ids which have their past given to this model should not be passed as input_ids as\nthey have already been computed.\n
use_mems has to be set to True to make use of mems.
perm_mask (torch.FloatTensor of shape (batch_size, sequence_length, sequence_length), optional) —\nMask to indicate the attention pattern for each input token with values selected in [0, 1]:\n
\n
if perm_mask[k, i, j] = 0, i attend to j in batch k;
\n
if perm_mask[k, i, j] = 1, i does not attend to j in batch k.
\n
\n
If not set, each token attends to all the others (full bidirectional attention). Only used during\npretraining (to define factorization order) or for sequential decoding (generation).
target_mapping (torch.FloatTensor of shape (batch_size, num_predict, sequence_length), optional) —\nMask to indicate the output tokens to use. If target_mapping[k, i, j] = 1, the i-th predict in batch k is\non the j-th token. Only used during pretraining for partial prediction or for sequential decoding\n(generation).
token_type_ids (torch.LongTensor of shape (batch_size, num_choices, sequence_length), optional) —\nSegment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:\n
input_mask (torch.FloatTensor of shape batch_size, num_choices, sequence_length, optional) —\nMask to avoid performing attention on padding token indices. Negative of attention_mask, i.e. with 0 for\nreal tokens and 1 for padding which is kept for compatibility with the original code base.\n
Mask values selected in [0, 1]:
\n
\n
1 for tokens that are masked,
\n
0 for tokens that are not masked.
\n
\n
You can only uses one of input_mask and attention_mask.
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) —\nMask to nullify selected heads of the self-attention modules. Mask values selected in [0, 1]:\n
\n
1 indicates the head is not masked,
\n
0 indicates the head is masked.
\n
inputs_embeds (torch.FloatTensor of shape (batch_size, num_choices, sequence_length, hidden_size), optional) —\nOptionally, instead of passing input_ids you can choose to directly pass an embedded representation. This\nis useful if you want more control over how to convert input_ids indices into associated vectors than the\nmodel’s internal embedding lookup matrix.
output_attentions (bool, optional) —\nWhether or not to return the attentions tensors of all attention layers. See attentions under returned\ntensors for more detail.
output_hidden_states (bool, optional) —\nWhether or not to return the hidden states of all layers. See hidden_states under returned tensors for\nmore detail.
return_dict (bool, optional) —\nWhether or not to return a ModelOutput instead of a plain tuple.
labels (tf.Tensor of shape (batch_size,), optional) —\nLabels for computing the multiple choice classification loss. Indices should be in [0, ..., num_choices]\nwhere num_choices is the size of the second dimension of the input tensors. (See input_ids above)
loss (tf.Tensor of shape (1,), optional, returned when labels is provided) — Classification loss.
\n
\n
\n
logits (tf.Tensor of shape (batch_size, num_choices)) — num_choices is the second dimension of the input tensors. (see input_ids above).
\n
Classification scores (before SoftMax).
\n
\n
\n
mems (List[tf.Tensor] of length config.n_layers) — Contains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
\n
\n
\n
hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape\n(batch_size, sequence_length, hidden_size).
\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
\n
\n
\n
attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).
\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
Although the recipe for forward pass needs to be defined within this function, one should call the Module\ninstance afterwards instead of this since the former takes care of running the pre and post processing steps while\nthe latter silently ignores them.
Example:
>>> from transformers import AutoTokenizer, TFXLNetForMultipleChoice\n>>> import tensorflow as tf\n\n>>> tokenizer = AutoTokenizer.from_pretrained(\"xlnet-base-cased\")\n>>> model = TFXLNetForMultipleChoice.from_pretrained(\"xlnet-base-cased\")\n\n>>> prompt = \"In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced.\"\n>>> choice0 = \"It is eaten with a fork and a knife.\"\n>>> choice1 = \"It is eaten while held in the hand.\"\n\n>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors=\"tf\", padding=True)\n>>> inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}\n>>> outputs = model(inputs) # batch size is 1\n\n>>> # the linear classifier still needs to be trained\n>>> logits = outputs.logits
config (XLNetConfig) — Model configuration class with all the parameters of the model.\nInitializing with a config file does not load the weights associated with the model, only the\nconfiguration. Check out the from_pretrained() method to load the model weights.
XLNet Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for\nNamed-Entity-Recognition (NER) tasks.
This model inherits from TFPreTrainedModel. Check the superclass documentation for the generic methods the\nlibrary implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\netc.)
This model is also a tf.keras.Model subclass. Use it\nas a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and\nbehavior.
TensorFlow models and layers in transformers accept two formats as input:
having all inputs as keyword arguments (like PyTorch models), or
having all inputs as a list, tuple or dict in the first positional argument.
The reason the second format is supported is that Keras methods prefer this format when passing inputs to models\nand layers. Because of this support, when using methods like model.fit() things should “just work” for you - just\npass your inputs and labels in any format that model.fit() supports! If, however, you want to use the second\nformat outside of Keras methods like fit() and predict(), such as when creating your own layers or models with\nthe Keras Functional API, there are three possibilities you can use to gather all the input Tensors in the first\npositional argument:
a single Tensor with input_ids only and nothing else: model(input_ids)
a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:\nmodel([input_ids, attention_mask]) or model([input_ids, attention_mask, token_type_ids])
a dictionary with one or several input Tensors associated to the input names given in the docstring:\nmodel({\"input_ids\": input_ids, \"token_type_ids\": token_type_ids})
Note that when creating models and layers with\nsubclassing then you don’t need to worry\nabout any of this, as you can just pass inputs like you would to any other Python function!
mems (List[torch.FloatTensor] of length config.n_layers) —\nContains pre-computed hidden-states (see mems output below) . Can be used to speed up sequential\ndecoding. The token ids which have their past given to this model should not be passed as input_ids as\nthey have already been computed.\n
use_mems has to be set to True to make use of mems.
perm_mask (torch.FloatTensor of shape (batch_size, sequence_length, sequence_length), optional) —\nMask to indicate the attention pattern for each input token with values selected in [0, 1]:\n
\n
if perm_mask[k, i, j] = 0, i attend to j in batch k;
\n
if perm_mask[k, i, j] = 1, i does not attend to j in batch k.
\n
\n
If not set, each token attends to all the others (full bidirectional attention). Only used during\npretraining (to define factorization order) or for sequential decoding (generation).
target_mapping (torch.FloatTensor of shape (batch_size, num_predict, sequence_length), optional) —\nMask to indicate the output tokens to use. If target_mapping[k, i, j] = 1, the i-th predict in batch k is\non the j-th token. Only used during pretraining for partial prediction or for sequential decoding\n(generation).
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) —\nSegment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:\n
input_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) —\nMask to avoid performing attention on padding token indices. Negative of attention_mask, i.e. with 0 for\nreal tokens and 1 for padding which is kept for compatibility with the original code base.\n
Mask values selected in [0, 1]:
\n
\n
1 for tokens that are masked,
\n
0 for tokens that are not masked.
\n
\n
You can only uses one of input_mask and attention_mask.
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) —\nMask to nullify selected heads of the self-attention modules. Mask values selected in [0, 1]:\n
\n
1 indicates the head is not masked,
\n
0 indicates the head is masked.
\n
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) —\nOptionally, instead of passing input_ids you can choose to directly pass an embedded representation. This\nis useful if you want more control over how to convert input_ids indices into associated vectors than the\nmodel’s internal embedding lookup matrix.
output_attentions (bool, optional) —\nWhether or not to return the attentions tensors of all attention layers. See attentions under returned\ntensors for more detail.
output_hidden_states (bool, optional) —\nWhether or not to return the hidden states of all layers. See hidden_states under returned tensors for\nmore detail.
return_dict (bool, optional) —\nWhether or not to return a ModelOutput instead of a plain tuple.
labels (tf.Tensor of shape (batch_size, sequence_length), optional) —\nLabels for computing the token classification loss. Indices should be in [0, ..., config.num_labels - 1].
mems (List[tf.Tensor] of length config.n_layers) — Contains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
\n
\n
\n
hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape\n(batch_size, sequence_length, hidden_size).
\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
\n
\n
\n
attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).
\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
Although the recipe for forward pass needs to be defined within this function, one should call the Module\ninstance afterwards instead of this since the former takes care of running the pre and post processing steps while\nthe latter silently ignores them.
Example:
>>> from transformers import AutoTokenizer, TFXLNetForTokenClassification\n>>> import tensorflow as tf\n\n>>> tokenizer = AutoTokenizer.from_pretrained(\"xlnet-base-cased\")\n>>> model = TFXLNetForTokenClassification.from_pretrained(\"xlnet-base-cased\")\n\n>>> inputs = tokenizer(\n... \"HuggingFace is a company based in Paris and New York\", add_special_tokens=False, return_tensors=\"tf\"\n... )\n\n>>> logits = model(**inputs).logits\n>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-1)\n\n>>> # Note that tokens are classified rather then input words which means that\n>>> # there might be more predicted token classes than words.\n>>> # Multiple token classes might account for the same word\n>>> predicted_tokens_classes = [model.config.id2label[t] for t in predicted_token_class_ids[0].numpy().tolist()]
>>> labels = predicted_token_class_ids\n>>> loss = tf.math.reduce_mean(model(**inputs, labels=labels).loss)
config (XLNetConfig) — Model configuration class with all the parameters of the model.\nInitializing with a config file does not load the weights associated with the model, only the\nconfiguration. Check out the from_pretrained() method to load the model weights.
XLNet Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear\nlayers on top of the hidden-states output to compute span start logits and span end logits).
This model inherits from TFPreTrainedModel. Check the superclass documentation for the generic methods the\nlibrary implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\netc.)
This model is also a tf.keras.Model subclass. Use it\nas a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and\nbehavior.
TensorFlow models and layers in transformers accept two formats as input:
having all inputs as keyword arguments (like PyTorch models), or
having all inputs as a list, tuple or dict in the first positional argument.
The reason the second format is supported is that Keras methods prefer this format when passing inputs to models\nand layers. Because of this support, when using methods like model.fit() things should “just work” for you - just\npass your inputs and labels in any format that model.fit() supports! If, however, you want to use the second\nformat outside of Keras methods like fit() and predict(), such as when creating your own layers or models with\nthe Keras Functional API, there are three possibilities you can use to gather all the input Tensors in the first\npositional argument:
a single Tensor with input_ids only and nothing else: model(input_ids)
a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:\nmodel([input_ids, attention_mask]) or model([input_ids, attention_mask, token_type_ids])
a dictionary with one or several input Tensors associated to the input names given in the docstring:\nmodel({\"input_ids\": input_ids, \"token_type_ids\": token_type_ids})
Note that when creating models and layers with\nsubclassing then you don’t need to worry\nabout any of this, as you can just pass inputs like you would to any other Python function!
mems (List[torch.FloatTensor] of length config.n_layers) —\nContains pre-computed hidden-states (see mems output below) . Can be used to speed up sequential\ndecoding. The token ids which have their past given to this model should not be passed as input_ids as\nthey have already been computed.\n
use_mems has to be set to True to make use of mems.
perm_mask (torch.FloatTensor of shape (batch_size, sequence_length, sequence_length), optional) —\nMask to indicate the attention pattern for each input token with values selected in [0, 1]:\n
\n
if perm_mask[k, i, j] = 0, i attend to j in batch k;
\n
if perm_mask[k, i, j] = 1, i does not attend to j in batch k.
\n
\n
If not set, each token attends to all the others (full bidirectional attention). Only used during\npretraining (to define factorization order) or for sequential decoding (generation).
target_mapping (torch.FloatTensor of shape (batch_size, num_predict, sequence_length), optional) —\nMask to indicate the output tokens to use. If target_mapping[k, i, j] = 1, the i-th predict in batch k is\non the j-th token. Only used during pretraining for partial prediction or for sequential decoding\n(generation).
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) —\nSegment token indices to indicate first and second portions of the inputs. Indices are selected in [0, 1]:\n
input_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) —\nMask to avoid performing attention on padding token indices. Negative of attention_mask, i.e. with 0 for\nreal tokens and 1 for padding which is kept for compatibility with the original code base.\n
Mask values selected in [0, 1]:
\n
\n
1 for tokens that are masked,
\n
0 for tokens that are not masked.
\n
\n
You can only uses one of input_mask and attention_mask.
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) —\nMask to nullify selected heads of the self-attention modules. Mask values selected in [0, 1]:\n
\n
1 indicates the head is not masked,
\n
0 indicates the head is masked.
\n
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) —\nOptionally, instead of passing input_ids you can choose to directly pass an embedded representation. This\nis useful if you want more control over how to convert input_ids indices into associated vectors than the\nmodel’s internal embedding lookup matrix.
output_attentions (bool, optional) —\nWhether or not to return the attentions tensors of all attention layers. See attentions under returned\ntensors for more detail.
output_hidden_states (bool, optional) —\nWhether or not to return the hidden states of all layers. See hidden_states under returned tensors for\nmore detail.
return_dict (bool, optional) —\nWhether or not to return a ModelOutput instead of a plain tuple.
start_positions (tf.Tensor of shape (batch_size,), optional) —\nLabels for position (index) of the start of the labelled span for computing the token classification loss.\nPositions are clamped to the length of the sequence (sequence_length). Position outside of the sequence\nare not taken into account for computing the loss.
end_positions (tf.Tensor of shape (batch_size,), optional) —\nLabels for position (index) of the end of the labelled span for computing the token classification loss.\nPositions are clamped to the length of the sequence (sequence_length). Position outside of the sequence\nare not taken into account for computing the loss.
loss (tf.Tensor of shape (1,), optional, returned when labels is provided) — Total span extraction loss is the sum of a Cross-Entropy for the start and end positions.
mems (List[tf.Tensor] of length config.n_layers) — Contains pre-computed hidden-states. Can be used (see mems input) to speed up sequential decoding. The\ntoken ids which have their past given to this model should not be passed as input_ids as they have\nalready been computed.
\n
\n
\n
hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of tf.Tensor (one for the output of the embeddings + one for the output of each layer) of shape\n(batch_size, sequence_length, hidden_size).
\n
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
\n
\n
\n
attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).
\n
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention\nheads.
Although the recipe for forward pass needs to be defined within this function, one should call the Module\ninstance afterwards instead of this since the former takes care of running the pre and post processing steps while\nthe latter silently ignores them.
Example:
>>> from transformers import AutoTokenizer, TFXLNetForQuestionAnsweringSimple\n>>> import tensorflow as tf\n\n>>> tokenizer = AutoTokenizer.from_pretrained(\"xlnet-base-cased\")\n>>> model = TFXLNetForQuestionAnsweringSimple.from_pretrained(\"xlnet-base-cased\")\n\n>>> question, text = \"Who was Jim Henson?\", \"Jim Henson was a nice puppet\"\n\n>>> inputs = tokenizer(question, text, return_tensors=\"tf\")\n>>> outputs = model(**inputs)\n\n>>> answer_start_index = int(tf.math.argmax(outputs.start_logits, axis=-1)[0])\n>>> answer_end_index = int(tf.math.argmax(outputs.end_logits, axis=-1)[0])\n\n>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> # target is \"nice puppet\"\n>>> target_start_index = tf.constant([14])\n>>> target_end_index = tf.constant([15])\n\n>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)\n>>> loss = tf.math.reduce_mean(outputs.loss)