ESM
概述
本页面提供了 Meta AI 基础人工智能研究团队的 Transformer 蛋白质语言模型的代码和预训练权重，包括最先进的 ESMFold 和 ESM-2，以及先前发布的 ESM-1b 和 ESM-1v。Transformer 蛋白质语言模型在论文 Biological structure and function emerge from scaling unsupervised learning to 250 million protein sequences 中被介绍，作者包括 Alexander Rives, Joshua Meier, Tom Sercu, Siddharth Goyal, Zeming Lin, Jason Liu, Demi Guo, Myle Ott, C. Lawrence Zitnick, Jerry Ma, 和 Rob Fergus。该论文的第一版于 2019 年预印。
ESM-2 在一系列结构预测任务中优于所有经过测试的单序列蛋白质语言模型，并实现了原子分辨率的结构预测。它与论文 Language models of protein sequences at the scale of evolution enable accurate structure prediction 一起发布，作者包括 Zeming Lin, Halil Akin, Roshan Rao, Brian Hie, Zhongkai Zhu, Wenting Lu, Allan dos Santos Costa, Maryam Fazel-Zarandi, Tom Sercu, Sal Candido 和 Alexander Rives。
本文还介绍了 ESMFold。它使用 ESM-2 主干和一个头部，可以以最先进的精度预测折叠的蛋白质结构。与 AlphaFold2 不同，它依赖于来自大型预训练蛋白质语言模型主干的词符嵌入，并且在推理时不执行多序列比对 (MSA) 步骤，这意味着 ESMFold 检查点是完全“独立的” - 它们不需要已知蛋白质序列和结构的数据库以及相关的外部查询工具来进行预测，因此速度更快。
“通过将无监督学习扩展到 2.5 亿个蛋白质序列，生物结构和功能得以涌现” 这篇论文的摘要是：
在人工智能领域，数据规模和模型容量的结合，通过无监督学习实现，已在表征学习和统计生成方面取得了重大进展。在生命科学领域，预计测序技术的增长将带来前所未有的关于自然序列多样性的数据。进化规模的蛋白质语言建模是迈向生物学预测和生成式人工智能的逻辑步骤。为此，我们使用无监督学习在跨越进化多样性的 2.5 亿个蛋白质序列中的 860 亿个氨基酸上训练了一个深度上下文语言模型。由此产生的模型在其表征中包含有关生物学特性的信息。这些表征仅从序列数据中学习而来。学习到的表征空间具有多尺度组织，反映了从氨基酸的生物化学特性到蛋白质的远程同源性的结构。关于二级和三级结构的信息被编码在表征中，并且可以通过线性投影来识别。表征学习产生的功能可以推广到各种应用，从而实现最先进的突变效应和二级结构的监督预测，并改进用于远程接触预测的最先进的功能。
“进化规模的蛋白质序列语言模型实现了准确的结构预测” 这篇论文的摘要是：
最近的研究表明，大型语言模型随着规模的扩大而发展出涌现能力，超越了简单的模式匹配，能够执行更高级别的推理并生成逼真的图像和文本。虽然在较小规模上已经研究了在蛋白质序列上训练的语言模型，但对于它们在规模扩大时学习到的关于生物学的知识知之甚少。在这项工作中，我们训练了参数高达 150 亿的模型，这是迄今为止评估的最大的蛋白质语言模型。我们发现，随着模型的扩展，它们学习到的信息能够预测蛋白质在单个原子分辨率下的三维结构。我们提出了 ESMFold，用于直接从蛋白质的单个序列进行高精度端到端原子级结构预测。对于语言模型充分理解的低困惑度序列，ESMFold 具有与 AlphaFold2 和 RoseTTAFold 相似的精度。ESMFold 推理比 AlphaFold2 快一个数量级，从而可以在实际时间尺度内探索宏基因组蛋白质的结构空间。
原始代码可以在 这里 找到，由 Meta AI 的基础人工智能研究团队开发。ESM-1b、ESM-1v 和 ESM-2 由 jasonliu 和 Matt 贡献给 huggingface。
ESMFold 由 Matt 和 Sylvain 贡献给 huggingface，非常感谢 Nikita Smetanin、Roshan Rao 和 Tom Sercu 在整个过程中的帮助！
使用技巧
- ESM 模型使用掩码语言建模 (MLM) 目标进行训练。
- HuggingFace 版本的 ESMFold 使用了 openfold 库的部分内容。openfold 库在 Apache License 2.0 下获得许可。
资源
EsmConfig
class transformers.EsmConfig
< source >( vocab_size = None mask_token_id = None pad_token_id = None hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 1026 initializer_range = 0.02 layer_norm_eps = 1e-12 position_embedding_type = 'absolute' use_cache = True emb_layer_norm_before = None token_dropout = False is_folding_model = False esmfold_config = None vocab_list = None **kwargs )
Parameters
- vocab_size (
int, optional) — ESM 模型的词汇表大小。定义了在调用ESMModel时传递的inputs_ids可以表示的不同 tokens 的数量。 - mask_token_id (
int, optional) — 词汇表中 mask token 的索引。 这必须包含在配置中，因为“mask-dropout”缩放技巧会根据 masked tokens 的数量来缩放输入。 - pad_token_id (
int, optional) — 词汇表中 padding token 的索引。 这必须包含在配置中，因为 ESM 代码的某些部分使用它来代替 attention mask。 - hidden_size (
int, optional, defaults to 768) — 编码器层和池化层的维度。 - num_hidden_layers (
int, optional, defaults to 12) — Transformer 编码器中隐藏层的数量。 - num_attention_heads (
int, optional, defaults to 12) — Transformer 编码器中每个 attention 层的 attention heads 数量。 - intermediate_size (
int, optional, defaults to 3072) — Transformer 编码器中“intermediate”（通常称为 feed-forward）层的维度。 - hidden_dropout_prob (
float, optional, defaults to 0.1) — embeddings、编码器和池化器中所有全连接层的 dropout 概率。 - attention_probs_dropout_prob (
float, optional, defaults to 0.1) — attention 概率的 dropout 比率。 - max_position_embeddings (
int, optional, defaults to 1026) — 该模型可能使用的最大序列长度。 通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。 - initializer_range (
float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float, optional, defaults to 1e-12) — layer normalization 层使用的 epsilon 值。 - position_embedding_type (
str, optional, defaults to"absolute") — 位置 embedding 的类型。 从"absolute","relative_key","relative_key_query", "rotary"中选择一个。 对于位置 embeddings，使用"absolute"。 有关"relative_key"的更多信息，请参考 Self-Attention with Relative Position Representations (Shaw et al.)。 有关"relative_key_query"的更多信息，请参考 Improve Transformer Models with Better Relative Position Embeddings (Huang et al.) 中的方法 4 。 - is_decoder (
bool, optional, defaults toFalse) — 模型是否用作 decoder。 如果为False，则模型用作 encoder。 - use_cache (
bool, optional, defaults toTrue) — 模型是否应返回上次的 key/values attentions (并非所有模型都使用)。 仅当config.is_decoder=True时相关。 - emb_layer_norm_before (
bool, optional) — 是否在 embeddings 之后但在网络主干之前应用 layer normalization。 - token_dropout (
bool, defaults toFalse) — 启用此项后，masked tokens 将被视为已被输入 dropout 丢弃。
这是用于存储 ESMModel 配置的配置类。 它用于根据指定的参数实例化 ESM 模型，从而定义模型架构。 使用默认值实例化配置将产生与 ESM facebook/esm-1b 架构类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。 有关更多信息，请阅读 PretrainedConfig 的文档。
Examples
>>> from transformers import EsmModel, EsmConfig
>>> # Initializing a ESM facebook/esm-1b style configuration >>> configuration = EsmConfig()
>>> # Initializing a model from the configuration >>> model = ESMModel(configuration)
>>> # Accessing the model configuration >>> configuration = model.configto_dict
< source >( ) → Dict[str, any]
Returns
Dict[str, any]
Dictionary of all the attributes that make up this configuration instance,
将此实例序列化为 Python 字典。 覆盖默认的 to_dict()。
EsmTokenizer
class transformers.EsmTokenizer
< source >( vocab_file unk_token = '<unk>' cls_token = '<cls>' pad_token = '<pad>' mask_token = '<mask>' eos_token = '<eos>' **kwargs )
构建 ESM tokenizer。
get_special_tokens_mask
< source >( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → [0, 1] 范围内整数的列表
从没有添加特殊 token 的 token 列表中检索序列 ID。当使用分词器的 prepare_for_model 或 encode_plus 方法添加特殊 token 时，会调用此方法。
create_token_type_ids_from_sequences
< source >( token_ids_0: List token_ids_1: Optional = None ) → List[int]
创建与传递的序列相对应的 token 类型 ID。 什么是 token 类型 ID？
如果模型具有构建这些 ID 的特殊方式，则应在子类中重写此方法。
EsmModel
class transformers.EsmModel
< source >( config add_pooling_layer = True )
Parameters
- config (EsmConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
裸 ESM 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的 head。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
该模型可以充当编码器（仅具有自注意力），也可以充当解码器，在后一种情况下，在自注意力层之间添加交叉注意力层，遵循 Attention is all you need （Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser 和 Illia Polosukhin 撰写）中描述的架构。
要充当解码器，模型需要在配置的 is_decoder 参数设置为 True 的情况下进行初始化。要在 Seq2Seq 模型中使用，模型需要使用 is_decoder 参数和 add_cross_attention 都设置为 True 进行初始化；然后，encoder_hidden_states 预计将作为前向传播的输入。
forward
< source >( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或 tuple(torch.FloatTensor)
Parameters
- input_ids (
torch.LongTensor，形状为((batch_size, sequence_length))) — 词汇表中输入序列 token 的索引。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形状为((batch_size, sequence_length))，可选) — 掩码，用于避免对填充 token 索引执行注意力。掩码值在[0, 1]中选择：- 1 代表未被掩盖的 token，
- 0 代表被掩盖的 token。
- position_ids (
torch.LongTensor，形状为((batch_size, sequence_length))，可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 掩码，用于使自注意力模块的选定 head 无效。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- inputs_embeds (
torch.FloatTensor，形状为((batch_size, sequence_length), hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。 - encoder_hidden_states (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 编码器最后一层输出的隐藏状态序列。 如果模型配置为解码器，则在交叉注意力中使用。 - encoder_attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 掩码，用于避免对编码器输入的填充 token 索引执行注意力。如果模型配置为解码器，则此掩码在交叉注意力中使用。掩码值在[0, 1]中选择：- 1 代表未被掩盖的 token，
- 0 代表被掩盖的 token。
- past_key_values (
tuple(tuple(torch.FloatTensor))，长度为config.n_layers，每个元组有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量) — 包含注意力模块的预计算的键和值隐藏状态。 可用于加速解码。如果使用
past_key_values，则用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids（那些没有将其过去的键值状态提供给此模型的），而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。 - use_cache (
bool, 可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。
Returns
transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (EsmConfig) 和输入。
-
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型最后一层的输出处的隐藏状态序列。 -
pooler_output (形状为
(batch_size, hidden_size)的torch.FloatTensor) — 序列的第一个 token（分类 token）的最后一层隐藏状态，在通过用于辅助预训练任务的层进一步处理之后。例如，对于 BERT 系列模型，这返回通过线性层和 tanh 激活函数处理后的分类 token。线性层权重通过预训练期间的下一句预测（分类）目标进行训练。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型具有嵌入层，则为嵌入输出一个，以及每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True和config.add_cross_attention=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
-
past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，并且如果config.is_encoder_decoder=True，则可选地有 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的额外张量。包含预先计算的隐藏状态（自注意力块中的键和值，以及如果
config.is_encoder_decoder=True，则可选地在交叉注意力块中），可用于（请参阅past_key_values输入）加速顺序解码。
EsmModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, EsmModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> model = EsmModel.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_stateEsmForMaskedLM
class transformers.EsmForMaskedLM
< source >( config )
Parameters
- config (EsmConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有 language modeling 头部的 ESM 模型。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 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 encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)
Parameters
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列 token 的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.FloatTensor, 可选) — 掩码，以避免对 padding token 索引执行注意力机制。掩码值在[0, 1]中选择：- 1 表示 token 未被掩盖，
- 0 表示 token 已被掩盖。
- position_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 每个输入序列 token 在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - head_mask (形状为
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor, 可选) — 掩码，用于使自注意力模块的选定 head 失效。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
- inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 用于计算 masked language modeling 损失的标签。索引应在[-100, 0, ..., config.vocab_size]中（请参阅input_ids文档字符串）。索引设置为-100的 Token 将被忽略（掩盖），损失仅针对标签在[0, ..., config.vocab_size]中的 token 计算 - kwargs (
Dict[str, any], 可选, 默认为{}) — 用于隐藏已弃用的旧版参数。
Returns
transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.MaskedLMOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (EsmConfig) 和输入。
-
loss (形状为
(1,)的torch.FloatTensor, 可选, 当提供labels时返回) — Masked language modeling (MLM) 损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模 head 的预测分数（SoftMax 之前每个词汇 token 的分数）。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型具有嵌入层，则为嵌入输出一个，以及每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
EsmForMaskedLM forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, EsmForMaskedLM
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> model = EsmForMaskedLM.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> # retrieve index of <mask>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]
>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
>>> outputs = model(**inputs, labels=labels)EsmForSequenceClassification
class transformers.EsmForSequenceClassification
< source >( config )
Parameters
- config (EsmConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有序列分类/回归头部的 ESM 模型转换器（pooled 输出顶部的线性层），例如用于 GLUE 任务。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 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 ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
Parameters
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列 tokens 的索引。索引可以通过 AutoTokenizer 获得。 详见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。
- attention_mask (形状为
(batch_size, sequence_length)的torch.FloatTensor, 可选) — 掩码，用于避免在 padding token 索引上执行 attention。 Mask values selected in[0, 1]:- 1 代表 tokens 未被掩盖，
- 0 代表 tokens 已被掩盖。
- position_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 位置嵌入中每个输入序列 tokens 的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - head_mask (形状为
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor, 可选) — 掩码，用于 nullify self-attention 模块的选定 heads。 Mask values selected in[0, 1]:- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
- inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回的 tensors 下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有 layers 的 hidden states。 有关更多详细信息，请参阅返回的 tensors 下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (形状为
(batch_size,)的torch.LongTensor, 可选) — 用于计算序列分类/回归损失的标签。 索引应在[0, ..., config.num_labels - 1]中。 如果config.num_labels == 1，则计算回归损失（均方损失）；如果config.num_labels > 1，则计算分类损失（交叉熵损失）。
Returns
transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (EsmConfig) 和输入。
-
loss (形状为
(1,)的torch.FloatTensor, 可选, 当提供labels时返回) — 分类（或回归，如果 config.num_labels==1）损失。 -
logits (形状为
(batch_size, config.num_labels)的torch.FloatTensor) — 分类（或回归，如果 config.num_labels==1）得分（SoftMax 之前）。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型具有嵌入层，则为嵌入输出一个，以及每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
EsmForSequenceClassification forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
单标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, EsmForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> model = EsmForSequenceClassification.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> # 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 = EsmForSequenceClassification.from_pretrained("facebook/esm2_t6_8M_UR50D", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss多标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, EsmForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> model = EsmForSequenceClassification.from_pretrained("facebook/esm2_t6_8M_UR50D", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # 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 = EsmForSequenceClassification.from_pretrained(
... "facebook/esm2_t6_8M_UR50D", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).lossEsmForTokenClassification
class transformers.EsmForTokenClassification
< source >( config )
Parameters
- config (EsmConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
ESM 模型，顶部带有一个 token 分类头（隐藏状态输出顶部的线性层），例如，用于命名实体识别 (NER) 任务。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 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 ) → transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)
Parameters
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列 tokens 的索引。索引可以通过 AutoTokenizer 获得。 详见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。
- attention_mask (形状为
(batch_size, sequence_length)的torch.FloatTensor, 可选) — 掩码，用于避免在 padding token 索引上执行 attention。 Mask values selected in[0, 1]:- 1 代表 tokens 未被掩盖，
- 0 代表 tokens 已被掩盖。
- position_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 位置嵌入中每个输入序列 tokens 的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - head_mask (形状为
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor, 可选) — 掩码，用于 nullify self-attention 模块的选定 heads。 Mask values selected in[0, 1]:- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
- inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回的 tensors 下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有 layers 的 hidden states。 有关更多详细信息，请参阅返回的 tensors 下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 用于计算 token 分类损失的标签。 索引应在[0, ..., config.num_labels - 1]中。
Returns
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时返回) —torch.FloatTensor的元组（如果模型具有嵌入层，则为嵌入输出一个，以及每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
EsmForTokenClassification forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应该在之后调用 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).lossEsmForProteinFolding
class transformers.EsmForProteinFolding
< source >( config )
Parameters
- config (EsmConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
ESMForProteinFolding 是 HuggingFace 移植的原始 ESMFold 模型。它由 ESM-2 “主干” 和一个蛋白质折叠 “头部” 组成，尽管与大多数其他输出头不同，这个 “头部” 在大小和运行时方面与模型其余部分的总和相似！它输出一个字典，其中包含关于输入蛋白质的预测结构信息。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: Tensor attention_mask: Optional = None position_ids: Optional = None masking_pattern: Optional = None num_recycles: Optional = None ) → transformers.models.esm.modeling_esmfold.EsmForProteinFoldingOutput 或 tuple(torch.FloatTensor)
Parameters
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。可以使用 AutoTokenizer 获取索引。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 获取详细信息。
- attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length), 可选) — 掩码，用于避免在 padding token 索引上执行 attention。 掩码值在[0, 1]中选择：- 1 表示 tokens 未被掩码，
- 0 表示 tokens 被掩码。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length), 可选) — 位置 embeddings 中每个输入序列 tokens 的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - masking_pattern (
torch.LongTensor，形状为(batch_size, sequence_length), 可选) — 在训练期间要掩码的 tokens 位置，作为一种正则化形式。 掩码值在[0, 1]中选择。 - num_recycles (
int, 可选, 默认为None) — 输入序列的循环次数。 如果为None，则默认为config.num_recycles。 “循环” 包括将折叠主干的输出重新作为输入传递到主干中。 在训练期间，循环次数应随每个批次而变化，以确保模型学习在每次循环后输出有效的预测。 在推理期间，num_recycles应设置为模型训练时的最大值，以获得最大精度。 因此，当此值设置为None时，将使用config.max_recycles。
Returns
transformers.models.esm.modeling_esmfold.EsmForProteinFoldingOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.esm.modeling_esmfold.EsmForProteinFoldingOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (<class 'transformers.models.esm.configuration_esm.EsmConfig'>) 和输入。
- 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 主干的每一层的隐藏状态得出的每个残基的 embeddings。 - s_z (
torch.FloatTensor) — 成对残基 embeddings。 - distogram_logits (
torch.FloatTensor) — 用于计算残基距离的距离图的输入 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) — 蛋白质链中每个残基的索引。 除非使用内部 padding tokens，否则这将只是从 0 到sequence_length的整数序列。 - lddt_head (
torch.FloatTensor) — 来自 lddt 头的原始输出，用于计算 plddt。 - plddt (
torch.FloatTensor) — 每个残基的置信度评分。 低置信度区域可能表明模型预测不确定的区域，或蛋白质结构无序的区域。 - ptm_logits (
torch.FloatTensor) — 用于计算 ptm 的原始 logits。 - ptm (
torch.FloatTensor) — 代表模型对整体结构的高级置信度的 TM-score 输出。 - aligned_confidence_probs (
torch.FloatTensor) — 对齐结构的每个残基的置信度评分。 - predicted_aligned_error (
torch.FloatTensor) — 模型预测与真实值之间的预测误差。 - max_predicted_aligned_error (
torch.FloatTensor) — 每个样本的最大预测误差。
EsmForProteinFolding forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应该在之后调用 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.positionsTFEsmModel
class transformers.TFEsmModel
< source >( config: EsmConfig add_pooling_layer = True *inputs **kwargs )
Parameters
- config (EsmConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
裸 ESM 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的 head。
此模型继承自 TFPreTrainedModel。 查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、剪枝 heads 等）。
此模型也是 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 ) → transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions 或 tuple(tf.Tensor)
Parameters
- input_ids (
tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。可以使用 AutoTokenizer 获取索引。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 获取详细信息。
- attention_mask (
tf.Tensor，形状为(batch_size, sequence_length), 可选) — 掩码，用于避免在 padding token 索引上执行 attention。 掩码值在[0, 1]中选择：- 1 表示 tokens 未被掩码，
- 0 表示 tokens 被掩码。
- position_ids (
tf.Tensor，形状为(batch_size, sequence_length), 可选) — 位置 embeddings 中每个输入序列 tokens 的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - head_mask (
tf.Tensor，形状为(num_heads,)或(num_layers, num_heads), 可选) — 掩码，用于使 self-attention 模块的选定 heads 无效。 掩码值在[0, 1]中选择：- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
- inputs_embeds (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。 如果您希望比模型的内部 embedding 查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回的 tensors 下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通的元组。 - encoder_hidden_states (
tf.Tensorof shape(batch_size, sequence_length, hidden_size), optional) — 编码器最后一层输出的隐藏状态序列。 如果模型配置为解码器，则在交叉注意力中被使用。 - encoder_attention_mask (
tf.Tensorof shape(batch_size, sequence_length), optional) — 用于避免在编码器输入的填充 token 索引上执行 attention 的掩码。 如果模型配置为解码器，则此掩码在交叉注意力中被使用。 掩码值在[0, 1]中选择：- 1 表示 未被掩码 的 token，
- 0 表示 被掩码 的 token。
- past_key_values (
Tuple[Tuple[tf.Tensor]]of lengthconfig.n_layers) — 包含 attention 块的预计算的键和值隐藏状态。 可用于加速解码。 如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids(那些没有将其过去的键值状态提供给此模型的) 形状为(batch_size, 1)而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - use_cache (
bool, optional, defaults toTrue) — 如果设置为True，则返回past_key_values键值状态，并且可以用于加速解码 (参见past_key_values)。 训练时设置为False，生成时设置为True
Returns
transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions 或 tuple(tf.Tensor)
A transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (EsmConfig) 和输入。
-
last_hidden_state (
tf.Tensorof shape(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 -
pooler_output (
tf.Tensorof shape(batch_size, hidden_size)) — 序列的第一个 token (分类 token) 的最后一层隐藏状态，通过线性层和 Tanh 激活函数进一步处理。 线性层权重在预训练期间从下一句预测（分类）目标中训练而来。此输出通常 *不是* 输入语义内容的良好摘要，通常最好对整个输入序列的隐藏状态序列进行平均或池化。
-
past_key_values (
List[tf.Tensor], optional, returned whenuse_cache=Trueis passed or whenconfig.use_cache=True) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含预计算的隐藏状态（attention 块中的键和值），可以用于加速顺序解码 (参见
past_key_values输入)。 -
hidden_states (
tuple(tf.Tensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) —tf.Tensor的元组（一个用于 embedding 的输出 + 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态加上初始 embedding 输出。
-
attentions (
tuple(tf.Tensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —tf.Tensor的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(tf.Tensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —tf.Tensor的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
TFEsmModel 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应该在之后调用 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_stateTFEsmForMaskedLM
class transformers.TFEsmForMaskedLM
< source >( config )
Parameters
- config (EsmConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
带有 language modeling 头部的 ESM 模型。
此模型继承自 TFPreTrainedModel。 查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、剪枝 heads 等）。
此模型也是 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 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 ) → transformers.modeling_tf_outputs.TFMaskedLMOutput 或 tuple(tf.Tensor)
Parameters
- input_ids (
tf.Tensorof shape(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
tf.Tensorof shape(batch_size, sequence_length), optional) — 用于避免在 padding token 索引上执行 attention 的掩码。 掩码值在[0, 1]中选择：- 1 表示 未被掩码 的 token，
- 0 表示 被掩码 的 token。
- position_ids (
tf.Tensorof shape(batch_size, sequence_length), optional) — 每个输入序列 token 在位置 embeddings 中的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - head_mask (
tf.Tensorof shape(num_heads,)or(num_layers, num_heads), optional) — 用于使自注意力模块的选定 head 无效的掩码。 掩码值在[0, 1]中选择：- 1 表示 head 未被掩蔽，
- 0 表示 head 被掩蔽。
- inputs_embeds (
tf.Tensorof shape(batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您想要更好地控制如何将input_ids索引转换为关联向量，这将非常有用。 - output_attentions (
bool, optional) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通的元组。 - labels (
tf.Tensorof shape(batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。 索引应为[-100, 0, ..., config.vocab_size](参见input_ids文档字符串) 索引设置为-100的 token 将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]中的 token 计算 - kwargs (
Dict[str, any], optional, defaults to{}) — 用于隐藏已弃用的旧版参数。
Returns
transformers.modeling_tf_outputs.TFMaskedLMOutput 或 tuple(tf.Tensor)
A transformers.modeling_tf_outputs.TFMaskedLMOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (EsmConfig) 和输入。
-
loss (
tf.Tensorof shape(n,), optional, where n is the number of non-masked labels, returned whenlabelsis provided) — 掩码语言建模 (MLM) 损失。 -
logits (
tf.Tensorof shape(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。 -
hidden_states (
tuple(tf.Tensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) —tf.Tensor的元组（一个用于 embedding 的输出 + 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态加上初始 embedding 输出。
-
attentions (
tuple(tf.Tensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —tf.Tensor的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
TFEsmForMaskedLM 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应该在之后调用 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)TFEsmForSequenceClassification
class transformers.TFEsmForSequenceClassification
< source >( config )
Parameters
- config (EsmConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有序列分类/回归头部的 ESM 模型转换器（pooled 输出顶部的线性层），例如用于 GLUE 任务。
此模型继承自 TFPreTrainedModel。 查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、剪枝 heads 等）。
此模型也是 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 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 ) → transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tuple(tf.Tensor)
Parameters
- input_ids (形状为
(batch_size, sequence_length)的tf.Tensor) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。
- attention_mask (形状为
(batch_size, sequence_length)的tf.Tensor, 可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]中选择:- 1 表示 tokens 未被 Mask，
- 0 表示 tokens 已被 Mask。
- position_ids (形状为
(batch_size, sequence_length)的tf.Tensor, 可选) — 每个输入序列 tokens 在 position embeddings 中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - head_mask (形状为
(num_heads,)或(num_layers, num_heads)的tf.Tensor, 可选) — 用于 nullify self-attention 模块中选定的 heads 的 Mask。 Mask 值在[0, 1]中选择:- 1 表示 head 未被 Mask，
- 0 表示 head 已被 Mask。
- inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)的tf.Tensor, 可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部 embedding 查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参见返回的 tensors 下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回的 tensors 下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通 tuple。 - labels (形状为
(batch_size,)的tf.Tensor, 可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels == 1，则计算回归损失（均方误差损失），如果config.num_labels > 1，则计算分类损失（交叉熵损失）。
Returns
transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个 tf.Tensor 的 tuple (如果传递 return_dict=False 或当 config.return_dict=False 时)，其中包含各种元素，具体取决于配置 (EsmConfig) 和输入。
-
loss (形状为
(batch_size, )的tf.Tensor, 可选, 当提供labels时返回) — 分类（或回归，如果 config.num_labels==1）损失。 -
logits (形状为
(batch_size, config.num_labels)的tf.Tensor) — 分类（或回归，如果 config.num_labels==1）得分（在 SoftMax 之前）。 -
hidden_states (
tuple(tf.Tensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) —tf.Tensor的元组（一个用于 embedding 的输出 + 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态加上初始 embedding 输出。
-
attentions (
tuple(tf.Tensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —tf.Tensor的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
TFEsmForSequenceClassification 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应该在之后调用 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).lossTFEsmForTokenClassification
class transformers.TFEsmForTokenClassification
< source >( config )
Parameters
- config (EsmConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
ESM 模型，顶部带有一个 token 分类头（隐藏状态输出顶部的线性层），例如，用于命名实体识别 (NER) 任务。
此模型继承自 TFPreTrainedModel。 查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、剪枝 heads 等）。
此模型也是 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 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 ) → transformers.modeling_tf_outputs.TFTokenClassifierOutput 或 tuple(tf.Tensor)
Parameters
- input_ids (形状为
(batch_size, sequence_length)的tf.Tensor) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。
- attention_mask (形状为
(batch_size, sequence_length)的tf.Tensor, 可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]中选择:- 1 表示 tokens 未被 Mask，
- 0 表示 tokens 已被 Mask。
- position_ids (形状为
(batch_size, sequence_length)的tf.Tensor, 可选) — 每个输入序列 tokens 在 position embeddings 中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - head_mask (形状为
(num_heads,)或(num_layers, num_heads)的tf.Tensor, 可选) — 用于 nullify self-attention 模块中选定的 heads 的 Mask。 Mask 值在[0, 1]中选择:- 1 表示 head 未被 Mask，
- 0 表示 head 已被 Mask。
- inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)的tf.Tensor, 可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部 embedding 查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 详见返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 详见返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。 - labels (
tf.Tensor，形状为(batch_size, sequence_length), optional) — 用于计算 token 分类损失的标签。索引应该在[0, ..., config.num_labels - 1]中。
Returns
transformers.modeling_tf_outputs.TFTokenClassifierOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFTokenClassifierOutput 或一个 tf.Tensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (EsmConfig) 和输入。
-
loss (
tf.Tensor，形状为(n,), optional, 其中 n 是未掩码标签的数量，当提供labels时返回) — 分类损失。 -
logits (
tf.Tensor，形状为(batch_size, sequence_length, config.num_labels)) — 分类得分 (SoftMax 之前)。 -
hidden_states (
tuple(tf.Tensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) —tf.Tensor的元组（一个用于 embedding 的输出 + 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态加上初始 embedding 输出。
-
attentions (
tuple(tf.Tensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —tf.Tensor的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
TFEsmForTokenClassification 的前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFEsmForTokenClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/esm2_t6_8M_UR50D")
>>> model = TFEsmForTokenClassification.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="tf"
... )
>>> logits = model(**inputs).logits
>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-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] for t in predicted_token_class_ids[0].numpy().tolist()]