Transformers 4.37 中文文档（三十二）（2）-阿里云开发者社区

Transformers 4.37 中文文档（三十二）（1）https://developer.aliyun.com/article/1564700

EsmForTokenClassification

`class transformers.EsmForTokenClassification`

( config )

参数

config (EsmConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

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

该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

该模型也是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

`forward`

< source >

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
什么是输入 ID？
attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

1 表示未被遮蔽的标记，
0 表示被遮蔽的标记。

什么是注意力掩码？
position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 每个输入序列标记在位置嵌入中的位置索引。选在范围[0, config.max_position_embeddings - 1]内。
什么是位置 ID？
head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块中的特定头部失效的掩码。掩码值选在[0, 1]之间：

1 表示头部未被遮蔽，
0 表示头部被遮蔽。

inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
labels (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]内。

transformers.modeling_outputs.TokenClassifierOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含各种元素，具体取决于配置（EsmConfig）和输入。

loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）-分类损失。
logits（形状为(batch_size, sequence_length, config.num_labels)的torch.FloatTensor）-分类分数（SoftMax 之前）。
hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）-形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出+每一层的输出）。
模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）-形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
在自注意力头中用于计算加权平均值的注意力权重 softmax 后。

EsmForTokenClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, EsmForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> model = EsmForTokenClassification.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss

EsmForProteinFolding

`class transformers.EsmForProteinFolding`

<来源>

( config )

参数

config（EsmConfig）-包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

ESMForProteinFolding 是原始 ESMFold 模型的 HuggingFace 移植版。它由一个 ESM-2“干”部分和一个蛋白质折叠“头”部分组成，尽管与大多数其他输出头部不同，这个“头”部分在大小和运行时间上与模型的其余部分相似！它输出一个包含关于输入蛋白质的预测结构信息的字典。

此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

`forward`

<来源>

( input_ids: Tensor attention_mask: Optional = None position_ids: Optional = None masking_pattern: Optional = None num_recycles: Optional = None ) → export const metadata = 'undefined';transformers.models.esm.modeling_esmfold.EsmForProteinFoldingOutput or tuple(torch.FloatTensor)

参数

input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）-词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
什么是输入 ID？
attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 避免在填充令牌索引上执行注意力的掩码。掩码值选在[0, 1]之间：

对于未被masked的令牌为 1，
对于被masked的令牌为 0。

什么是注意力掩码？
position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列令牌在位置嵌入中的位置索引。选在范围[0, config.max_position_embeddings - 1]内。
什么是位置 ID？
masking_pattern (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 在训练期间要屏蔽的令牌位置，作为一种正则化形式。掩码值选在[0, 1]之间。
num_recycles (int，可选，默认为None) — 重复输入序列的次数。如果为None，则默认为config.num_recycles。 “Recycling”包括将折叠主干的输出作为输入传递给主干。在训练期间，每个批次的循环次数应该随着每次循环而变化，以确保模型学会在每次循环后输出有效的预测。在推断期间，num_recycles 应设置为模型训练的最大值，以获得最大准确性。因此，当此值设置为None时，将使用 config.max_recycles。

transformers.models.esm.modeling_esmfold.EsmForProteinFoldingOutput或tuple(torch.FloatTensor)

一个transformers.models.esm.modeling_esmfold.EsmForProteinFoldingOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含根据配置()和输入的不同元素。

frames (torch.FloatTensor) — 输出的框架。
sidechain_frames (torch.FloatTensor) — 输出的侧链框架。
unnormalized_angles (torch.FloatTensor) — 预测的未归一化主链和侧链扭转角度。
angles (torch.FloatTensor) — 预测的主链和侧链扭转角度。
positions (torch.FloatTensor) — 预测的主链和侧链原子位置。
states (torch.FloatTensor) — 蛋白质折叠主干的隐藏状态。
s_s (torch.FloatTensor) — 通过连接 ESM-2 LM 干每一层的隐藏状态派生的每个残基的嵌入。
s_z (torch.FloatTensor) — 成对残基嵌入。
distogram_logits (torch.FloatTensor) — 用于计算残基距离的 distogram 的输入 logits。
lm_logits (torch.FloatTensor) — ESM-2 蛋白质语言模型干输出的 logits。
aatype (torch.FloatTensor) — 输入的氨基酸（AlphaFold2 索引）。
atom14_atom_exists (torch.FloatTensor) — 每个原子是否存在于 atom14 表示中。
residx_atom14_to_atom37 (torch.FloatTensor) — 在 atom14 和 atom37 表示之间的原子映射。
residx_atom37_to_atom14 (torch.FloatTensor) — 在 atom37 和 atom14 表示之间的原子映射。
atom37_atom_exists (torch.FloatTensor) — 每个原子是否存在于 atom37 表示中。
residue_index (torch.FloatTensor) — 蛋白质链中每个残基的索引。除非使用内部填充令牌，否则这将是从 0 到sequence_length的整数序列。
lddt_head (torch.FloatTensor) — 用于计算 plddt 的 lddt 头部的原始输出。
plddt (torch.FloatTensor) — 每个残基的置信度分数。低置信度区域可能表明模型预测不确定的区域，或者蛋白质结构无序的区域。
ptm_logits (torch.FloatTensor) — 用于计算 ptm 的原始对数。
ptm (torch.FloatTensor) — TM-score 输出，代表模型对整体结构的高级置信度。
aligned_confidence_probs (torch.FloatTensor) — 对齐结构的每个残基的置信度分数。
predicted_aligned_error (torch.FloatTensor) — 模型预测与真实值之间的预测误差。
max_predicted_aligned_error (torch.FloatTensor) — 每个样本的最大预测误差。

EsmForProteinFolding 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用 Module 实例，而不是在此处调用，因为前者会负责运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, EsmForProteinFolding
>>> model = EsmForProteinFolding.from_pretrained("facebook/esmfold_v1")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esmfold_v1")
>>> inputs = tokenizer(["MLKNVQVQLV"], return_tensors="pt", add_special_tokens=False)  # A tiny random peptide
>>> outputs = model(**inputs)
>>> folded_positions = outputs.positions

TensorFlow 隐藏 TensorFlow 内容

TFEsmModel

`class transformers.TFEsmModel`

< source >

( config: EsmConfig add_pooling_layer = True *inputs **kwargs )

参数

config (EsmConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。

裸 ESM 模型变压器输出原始隐藏状态，没有特定的头部。

该模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

该模型也是 Keras Model 子类。将其用作常规 Keras 模型，并参考 TF/Keras 文档以了解所有与一般使用和行为相关的事项。

`call`

< source >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None encoder_hidden_states: np.ndarray | tf.Tensor | None = None encoder_attention_mask: np.ndarray | tf.Tensor | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions or tuple(tf.Tensor)

参数

input_ids (tf.Tensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以获取详细信息。
什么是输入 ID？
attention_mask (tf.Tensor of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]：

1 表示 未被掩盖 的标记，
0 表示 被掩盖 的标记。

什么是注意力掩码？
position_ids (tf.Tensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选在范围 [0, config.max_position_embeddings - 1]。
什么是位置 ID？
head_mask (tf.Tensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选在 [0, 1]：

1 表示头部 未被掩盖。
0 表示头部被 掩盖。

inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）— 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这很有用。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。
encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）— 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。
encoder_attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选）— 避免对编码器输入的填充标记索引执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用。掩码值选择在[0, 1]中。

对于未被掩码的标记为 1，
对于被掩码的标记为 0。

past_key_values（长度为config.n_layers的Tuple[Tuple[tf.Tensor]]）— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为(batch_size, 1)而不是所有decoder_input_ids的形状为(batch_size, sequence_length)。
use_cache（bool，可选，默认为True）— 如果设置为True，将返回past_key_values键值状态，可用于加速解码（参见past_key_values）。在训练期间设置为False，在生成期间设置为True。

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions 或者tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions 或者一个tf.Tensor元组（如果传递了return_dict=False或者config.return_dict=False时）包括根据配置（EsmConfig）和输入的不同元素。

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）— 模型最后一层的隐藏状态序列。
pooler_output（形状为(batch_size, hidden_size)的tf.Tensor）— 序列第一个标记（分类标记）的最后一层隐藏状态，经过线性层和 Tanh 激活函数进一步处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
此输出通常不是输入的语义内容的良好摘要，您通常最好对整个输入序列的隐藏状态进行平均或池化。
past_key_values（List[tf.Tensor]，可选，当传递use_cache=True或者config.use_cache=True时返回）— 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。
包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。
hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）-形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出+一个用于每一层的输出）。
模型在每一层的输出处的隐藏状态加上初始嵌入输出。
attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）-形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。
注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）-形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。
解码器的交叉注意力层的注意力权重，在注意力 softmax 后使用，用于计算交叉注意力头中的加权平均值。

TFEsmModel 前向方法，覆盖__call__特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者负责运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFEsmModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> model = TFEsmModel.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> last_hidden_states = outputs.last_hidden_state

TFEsmForMaskedLM

`class transformers.TFEsmForMaskedLM`

<来源>

( config )

参数

config（EsmConfig）-模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

ESM 模型顶部带有语言建模头。

这个模型继承自 TFPreTrainedModel。查看超类文档以了解库实现的通用方法（如下载或保存，调整输入嵌入，修剪头等）。

这个模型也是 Keras Model 的子类。将其用作常规 Keras 模型，并参考 TF/Keras 文档以了解所有与一般用法和行为相关的事项。

`call`

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None encoder_hidden_states: np.ndarray | tf.Tensor | None = None encoder_attention_mask: np.ndarray | tf.Tensor | None = None labels: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMaskedLMOutput or tuple(tf.Tensor)

参数

input_ids（形状为(batch_size, sequence_length)的tf.Tensor）-词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。
什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选）-避免在填充标记索引上执行注意力的掩码。选择在[0, 1]中的掩码值：

对于未被屏蔽的标记为 1，
对于被屏蔽的标记为 0。

注意力掩码是什么？
position_ids (tf.Tensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。
什么是位置 ID？
head_mask (tf.Tensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于将自注意力模块的选定头部置零的掩码。掩码值选定在 [0, 1] 之间：

1 表示头部未被 masked。
0 表示头部被 masked。

inputs_embeds (tf.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权，以便将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
labels (tf.Tensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 范围内（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（masked），损失仅计算具有标签在 [0, ..., config.vocab_size] 范围内的标记。
kwargs (Dict[str, any], optional, 默认为 {}) — 用于隐藏已被弃用的旧参数。

transformers.modeling_tf_outputs.TFMaskedLMOutput 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFMaskedLMOutput 或一个 tf.Tensor 元组（如果传递 return_dict=False 或者 config.return_dict=False 时）包含各种元素，取决于配置（EsmConfig）和输入。

loss (tf.Tensor of shape (n,), optional, 其中 n 是非掩码标签的数量，在提供 labels 时返回) — 掩码语言建模（MLM）损失。
logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头部的预测分数（SoftMax 之前每个词汇标记的分数）。
hidden_states (tuple(tf.Tensor), optional, 当传递 output_hidden_states=True 或者 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入的输出 + 一个用于每层的输出）。
每层模型的隐藏状态加上初始嵌入输出。
attentions (tuple(tf.Tensor), optional, 当传递 output_attentions=True 或者 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。
在注意力 softmax 之后的注意力权重，用于计算自注意力头部中的加权平均值。

TFEsmForMaskedLM 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传播的步骤需要在此函数内定义，但应该在此之后调用 Module 实例，而不是在此处调用，因为前者负责运行前处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFEsmForMaskedLM
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> model = TFEsmForMaskedLM.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="tf")
>>> logits = model(**inputs).logits
>>> # retrieve index of <mask>
>>> mask_token_index = tf.where((inputs.input_ids == tokenizer.mask_token_id)[0])
>>> selected_logits = tf.gather_nd(logits[0], indices=mask_token_index)
>>> predicted_token_id = tf.math.argmax(selected_logits, axis=-1)

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="tf")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = tf.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
>>> outputs = model(**inputs, labels=labels)

TFEsmForSequenceClassification

`class transformers.TFEsmForSequenceClassification`

<来源>

( config )

参数

config（EsmConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

ESM 模型变压器，顶部带有序列分类/回归头（顶部的线性层在汇总输出之上），例如用于 GLUE 任务。

此模型继承自 TFPreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型还是 Keras Model子类。将其用作常规 Keras 模型，并参考 TF/Keras 文档以获取有关一般用法和行为的所有事项。

`call`

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None labels: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)

参数

input_ids（形状为(batch_size, sequence_length)的tf.Tensor）— 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

对于未屏蔽的标记为 1，
0 表示标记为屏蔽。

什么是注意力掩码？
position_ids（形状为(batch_size, sequence_length)的tf.Tensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。
什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的tf.Tensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]之间：

1 表示头部未被屏蔽，
0 表示头部被屏蔽。

inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为关联向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。
labels (tf.Tensor的形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（EsmConfig）和输入的各种元素。

loss (tf.Tensor的形状为(batch_size, )，可选，在提供labels时返回) — 分类（如果 config.num_labels==1 则为回归）损失。
logits (tf.Tensor的形状为(batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）分数（SoftMax 之前）。
hidden_states (tuple(tf.Tensor)，可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入输出，一个用于每一层的输出）。
模型在每一层输出的隐藏状态加上初始嵌入输出。
attentions (tuple(tf.Tensor)，可选，在传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。
在自注意力头中使用注意力 softmax 后的注意力权重，用于计算加权平均值。

TFEsmForSequenceClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在这个函数内定义，但应该在之后调用Module实例，而不是这个，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFEsmForSequenceClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> model = TFEsmForSequenceClassification.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> logits = model(**inputs).logits
>>> 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(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TFEsmForSequenceClassification.from_pretrained("facebook/esm2_t6_8M_UR50D", num_labels=num_labels)
>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss

Transformers 4.37 中文文档（三十二）（3）https://developer.aliyun.com/article/1564703

Transformers 4.37 中文文档（三十二）（2）

EsmForTokenClassification

`class transformers.EsmForTokenClassification`

`forward`

EsmForProteinFolding

`class transformers.EsmForProteinFolding`

`forward`

TFEsmModel

`class transformers.TFEsmModel`

`call`

TFEsmForMaskedLM

`class transformers.TFEsmForMaskedLM`

`call`

TFEsmForSequenceClassification

`class transformers.TFEsmForSequenceClassification`

`call`

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Transformers 4.37 中文文档（三十二）（2）

EsmForTokenClassification

class transformers.EsmForTokenClassification

forward

EsmForProteinFolding

class transformers.EsmForProteinFolding

forward

TFEsmModel

class transformers.TFEsmModel

call

TFEsmForMaskedLM

class transformers.TFEsmForMaskedLM

call

TFEsmForSequenceClassification

class transformers.TFEsmForSequenceClassification

call

热门文章

最新文章

相关课程

相关电子书

`class transformers.EsmForTokenClassification`

`forward`

`class transformers.EsmForProteinFolding`

`forward`

`class transformers.TFEsmModel`

`call`

`class transformers.TFEsmForMaskedLM`

`call`

`class transformers.TFEsmForSequenceClassification`

`call`