Transformers 文档

模型

Transformers

加入 Hugging Face 社区

并获得增强的文档体验

协作开发模型、数据集和空间

使用加速推理加快示例速度

在文档主题之间切换

开始使用

模型

基类 PreTrainedModel、TFPreTrainedModel 和 FlaxPreTrainedModel 实现了从本地文件或目录，或从库提供的预训练模型配置（从 HuggingFace 的 AWS S3 存储库下载）加载/保存模型的常用方法。

PreTrainedModel 和 TFPreTrainedModel 还实现了一些所有模型通用的方法，用于

在词汇表中添加新标记时调整输入标记嵌入的大小
修剪模型的注意力头。

每个模型通用的其他方法定义在 ModuleUtilsMixin（用于 PyTorch 模型）和 ~modeling_tf_utils.TFModuleUtilsMixin（用于 TensorFlow 模型）中，或者对于文本生成，定义在 GenerationMixin（用于 PyTorch 模型）、TFGenerationMixin（用于 TensorFlow 模型）和 FlaxGenerationMixin（用于 Flax/JAX 模型）中。

PreTrainedModel

类 transformers.PreTrainedModel

( config: PretrainedConfig *inputs **kwargs )

所有模型的基类。

PreTrainedModel 负责存储模型的配置，并处理加载、下载和保存模型的方法，以及所有模型通用的以下方法：

调整输入嵌入的大小，
在自注意力头中修剪头。

类属性（由派生类覆盖）

config_class (PretrainedConfig) — 用作此模型架构的配置类的 PretrainedConfig 的子类。
load_tf_weights (Callable) — 用于在 PyTorch 模型中加载 TensorFlow 检查点的 Python 方法，其参数为
- model (PreTrainedModel) — 要加载 TensorFlow 检查点的模型实例。
- config (PreTrainedConfig) — 与模型关联的配置实例。
- path (str) — TensorFlow 检查点的路径。
base_model_prefix (str) — 一个字符串，指示在相同架构的派生类中与基础模型关联的属性，这些派生类在基础模型之上添加了模块。
is_parallelizable (bool) — 一个标志，指示此模型是否支持模型并行化。
main_input_name (str) — 模型主要输入的名称（对于 NLP 模型通常为 input_ids，对于视觉模型为 pixel_values，对于语音模型为 input_values）。

push_to_hub

( repo_id: str use_temp_dir: Optional = None commit_message: Optional = None private: Optional = None token: Union = None max_shard_size: Union = '5GB' create_pr: bool = False safe_serialization: bool = True revision: str = None commit_description: str = None tags: Optional = None **deprecated_kwargs )

参数

repo_id (str) — 您想要将模型推送到的仓库名称。当推送到给定组织时，它应该包含您的组织名称。
use_temp_dir (bool, 可选) — 是否使用临时目录来存储保存的文件，然后再将其推送到 Hub。如果不存在名为 repo_id 的目录，则默认为 True，否则默认为 False。
commit_message (str, 可选) — 推送时提交的消息。默认为 "Upload model"。
private (bool, 可选) — 创建的仓库是否应该是私有的。
token (bool 或 str, 可选) — 用作远程文件 HTTP Bearer 授权的令牌。如果为 True，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。如果未指定 repo_url，则默认为 True。
max_shard_size (int 或 str，可选，默认为 "5GB") — 仅适用于模型。检查点分片前的最大大小。然后，每个检查点分片的大小都将小于此大小。如果表示为字符串，则需要是数字后跟单位（例如 "5MB"）。我们将其默认为 "5GB"，以便用户可以在免费层的 Google Colab 实例上轻松加载模型，而不会出现任何 CPU OOM 问题。
create_pr (bool，可选，默认为 False) — 是否使用上传的文件创建 PR 或直接提交。
safe_serialization (bool，可选，默认为 True) — 是否将模型权重转换为 safetensors 格式以进行更安全的序列化。
revision (str，可选) — 要将上传的文件推送到哪个分支。
commit_description (str，可选) — 将创建的提交的描述
tags (List[str]，可选) — 要在 Hub 上推送的标签列表。

将模型文件上传到 🤗 模型中心。

示例

from transformers import AutoModel

model = AutoModel.from_pretrained("google-bert/bert-base-cased")

# Push the model to your namespace with the name "my-finetuned-bert".
model.push_to_hub("my-finetuned-bert")

# Push the model to an organization with the name "my-finetuned-bert".
model.push_to_hub("huggingface/my-finetuned-bert")

add_model_tags

( tags: Union )

参数

tags (Union[List[str], str]) — 需要注入到推送到 Hugging Face Hub 的模型中的所需标签。

将自定义标签添加到推送到 Hugging Face Hub 的模型中。不会覆盖模型中现有的标签。

示例

from transformers import AutoModel

model = AutoModel.from_pretrained("google-bert/bert-base-cased")

model.add_model_tags(["custom", "custom-bert"])

# Push the model to your namespace with the name "my-custom-bert".
model.push_to_hub("my-custom-bert")

can_generate

( ) → bool

返回值

bool

此模型是否可以使用 .generate() 生成序列。

返回此模型是否可以使用 .generate() 生成序列。

dequantize

( )

如果模型已被支持反量化的量化方法量化，则可能对模型进行反量化。

disable_input_require_grads

( )

移除 _require_grads_hook。

enable_input_require_grads

( )

启用输入嵌入的梯度。这对于在保持模型权重固定的同时微调适配器权重很有用。

from_pretrained

( pretrained_model_name_or_path: Union *model_args config: Union = None cache_dir: Union = None ignore_mismatched_sizes: bool = False force_download: bool = False local_files_only: bool = False token: Union = None revision: str = 'main' use_safetensors: bool = None **kwargs )

参数

pretrained_model_name_or_path (str 或 os.PathLike, 可选) — 可以是以下任意一种:
- 一个字符串，表示 huggingface.co 上模型仓库中托管的预训练模型的 模型 ID。
- 一个指向目录的路径，该目录包含使用 save_pretrained() 保存的模型权重，例如 ./my_model_directory/。
- 一个指向 TensorFlow 索引检查点文件 的路径或 URL（例如 ./tf_model/model.ckpt.index）。在这种情况下，from_tf 应设置为 True，并且应提供一个配置对象作为 config 参数。此加载路径比使用提供的转换脚本将 TensorFlow 检查点转换为 PyTorch 模型并随后加载 PyTorch 模型要慢。
- 一个指向模型文件夹的路径或 URL，该文件夹包含 .msgpack 格式的 Flax 检查点文件（例如，包含 flax_model.msgpack 的 ./flax_model/）。在这种情况下，from_flax 应设置为 True。
- 如果您同时提供配置和状态字典（分别使用关键字参数 config 和 state_dict），则为 None。
model_args (位置参数序列, 可选) — 所有剩余的位置参数将传递给底层模型的 __init__ 方法。
config (Union[PretrainedConfig, str, os.PathLike], 可选) — 可以是以下任意一种:
- PretrainedConfig 派生类的实例，
- 作为 from_pretrained() 的输入有效的字符串或路径。
要使用的模型配置，而不是自动加载的配置。配置可以在以下情况下自动加载：
- 该模型是库提供的模型（使用预训练模型的 模型 ID 字符串加载）。
- 该模型是使用 save_pretrained() 保存的，并通过提供保存目录重新加载。
- 通过提供本地目录作为 pretrained_model_name_or_path 加载模型，并且在目录中找到名为 config.json 的配置 JSON 文件。
state_dict (Dict[str, torch.Tensor], 可选) — 要使用的状态字典，而不是从保存的权重文件加载的状态字典。

如果您想从预训练配置创建模型但加载自己的权重，则可以使用此选项。但是，在这种情况下，您应该检查使用 save_pretrained() 和 from_pretrained() 是否不是更简单的选择。
cache_dir (Union[str, os.PathLike], 可选) — 如果不应使用标准缓存，则为下载的预训练模型配置应缓存到的目录的路径。
from_tf (bool, 可选, 默认为 False) — 从 TensorFlow 检查点保存文件加载模型权重（请参阅 pretrained_model_name_or_path 参数的文档字符串）。
from_flax (bool, 可选, 默认为 False) — 从 Flax 检查点保存文件加载模型权重（请参阅 pretrained_model_name_or_path 参数的文档字符串）。
ignore_mismatched_sizes (bool, 可选, 默认为 False) — 如果检查点中的一些权重与模型的权重大小不匹配，是否引发错误（例如，您正在从具有 3 个标签的检查点实例化具有 10 个标签的模型）。
force_download (bool, 可选, 默认为 False) — 是否强制（重新）下载模型权重和配置文件，覆盖缓存版本（如果存在）。resume_download — 已弃用并被忽略。现在，所有下载在可能的情况下都会默认恢复。将在 Transformers 的 v5 版本中删除。
proxies (Dict[str, str], 可选) — 要按协议或端点使用的代理服务器字典，例如，{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}。代理用于每个请求。
output_loading_info(bool, 可选, 默认为 False) — 是否同时返回包含缺失键、意外键和错误消息的字典。
local_files_only(bool, 可选, 默认为 False) — 是否仅查看本地文件（即，不尝试下载模型）。
token (str 或 bool, 可选) — 用于远程文件的 HTTP Bearer 授权的令牌。如果为 True 或未指定，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。
revision (str, 可选, 默认为 "main") — 要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID，因为我们使用基于 git 的系统来存储 huggingface.co 上的模型和其他工件，所以 revision 可以是 git 允许的任何标识符。

要测试您在 Hub 上提交的拉取请求，您可以传递 `revision=“refs/pr/“`。
mirror (str, 可选) — 镜像源，用于加速在中国下载。如果您来自中国并且遇到访问问题，可以设置此选项来解决。请注意，我们不保证时效性和安全性。请参阅镜像站点了解更多信息。
_fast_init(bool, 可选, 默认为 True) — 是否禁用快速初始化。

仅应禁用 _fast_init 以确保与 transformers.__version__ < 4.6.0 的种子模型初始化向后兼容。此参数将在下一个主要版本中删除。请参阅拉取请求 11471 了解更多信息。
attn_implementation (str, 可选) — 模型中使用的注意力机制实现（如果相关）。可以是 "eager"（手动实现注意力）、"sdpa"（使用 F.scaled_dot_product_attention）或 "flash_attention_2"（使用 Dao-AILab/flash-attention）。默认情况下，如果可用，SDPA 将用于 torch>=2.1.1。否则默认为手动 "eager" 实现。

大模型推理参数

low_cpu_mem_usage(bool, 可选) — 尝试在加载模型时不使用超过模型大小 1 倍的 CPU 内存（包括峰值内存）。通常应与 device_map（例如 "auto"）结合使用以获得最佳效果。这是一项实验性功能，随时可能发生更改。
如果模型权重的精度与加载的模型相同，则 `low_cpu_mem_usage`（不带 `device_map`）是多余的，并且在 CPU 内存使用方面不会提供任何好处。但是，如果您传入 `device_map`，则仍应启用此功能。
torch_dtype (str 或 torch.dtype，可选) — 覆盖默认的 torch.dtype 并以特定的 dtype 加载模型。不同的选项有：
1. torch.float16 或 torch.bfloat16 或 torch.float：以指定的 dtype 加载，忽略模型的 config.torch_dtype（如果存在）。如果未指定
  - 模型将以 torch.float (fp32) 加载。
2. "auto" - 将尝试使用模型的 config.json 文件中的 torch_dtype 条目。如果找不到此条目，则接下来检查检查点中第一个浮点类型权重的 dtype 并将其用作 dtype。这将使用模型在训练结束时保存的 dtype 加载模型。它不能用作模型如何训练的指标。因为它可以以半精度 dtypes 之一进行训练，但以 fp32 保存。
3. 一个有效的 torch.dtype 字符串。例如，“float32”以 torch.float32 加载模型，“float16”以 torch.float16 加载模型，等等。
对于某些模型，它们训练的 dtype 是未知的 - 您可以尝试查看模型的论文或联系作者，让他们将此信息添加到模型的卡片中，并在 hub 上的 config.json 中插入 torch_dtype 条目。
device_map (str 或 Dict[str, Union[int, str, torch.device]] 或 int 或 torch.device，可选) — 指定每个子模块应放置位置的映射。它不需要精确到每个参数/缓冲区名称，一旦给定的模块名称在内部，它的每个子模块都将被发送到同一个设备。如果我们只传递将分配模型的设备（例如，"cpu"、"cuda:1"、"mps" 或 GPU 序数等级，如 1），则设备映射将把整个模型映射到此设备。传递 device_map = 0 表示将整个模型放在 GPU 0 上。

要让 Accelerate 自动计算最优化的 device_map，请设置 device_map="auto"。有关每个选项的更多信息，请参阅设计设备映射。
max_memory (Dict，可选) — 设备标识符到最大内存的字典。如果未设置，将默认为每个 GPU 的最大可用内存和可用的 CPU RAM。
offload_folder (str 或 os.PathLike，可选) — 如果 device_map 包含任何值 "disk"，则为我们将卸载权重的文件夹。
offload_state_dict (bool, 可选) — 如果为 True，如果 CPU 状态字典的权重加上检查点最大分片的权重不适合 CPU RAM，将临时将 CPU 状态字典卸载到硬盘驱动器，以避免耗尽 CPU RAM。当存在磁盘卸载时，默认为 True。
offload_buffers (bool, 可选) — 是否将缓冲区与模型参数一起卸载。
quantization_config (Union[QuantizationConfigMixin,Dict], 可选) — 用于量化的配置参数字典或 QuantizationConfigMixin 对象（例如 bitsandbytes、gptq）。可能还有其他与量化相关的 kwargs，包括 load_in_4bit 和 load_in_8bit，它们由 QuantizationConfigParser 解析。仅支持 bitsandbytes 量化，不推荐使用。请考虑将所有此类参数插入 quantization_config。
subfolder (str, 可选, 默认为 "") — 如果相关文件位于 huggingface.co 上模型仓库的子文件夹中，则可以在此处指定文件夹名称。
variant (str, 可选) — 如果指定，则从 variant 文件名加载权重，例如 pytorch_model..bin。使用 from_tf 或 from_flax 时，将忽略 variant。
use_safetensors (bool, 可选, 默认为 None) — 是否使用 safetensors 检查点。默认为 None。如果未指定且未安装 safetensors，则将其设置为 False。
kwargs (剩余的关键字参数字典, 可选) — 可用于更新配置对象（加载后）并初始化模型（例如，output_attentions=True）。根据是否提供或自动加载 config 的不同，其行为也会有所不同：
- 如果使用 config 提供了配置，则 **kwargs 将直接传递给底层模型的 __init__ 方法（我们假设已经完成了对配置的所有相关更新）
- 如果没有提供配置，则 kwargs 将首先传递给配置类的初始化函数 (from_pretrained())。kwargs 中与配置属性对应的每个键都将用于使用提供的 kwargs 值覆盖所述属性。不对应任何配置属性的剩余键将传递给底层模型的 __init__ 函数。

从预训练模型配置实例化一个预训练的 PyTorch 模型。

默认情况下，模型使用 model.eval() 设置为评估模式（Dropout 模块被停用）。要训练模型，您应该首先使用 model.train() 将其重新设置为训练模式。

警告 XXX 的权重未从预训练模型初始化 意味着 XXX 的权重没有与模型的其余部分一起预训练。您可以使用下游微调任务来训练这些权重。

警告 YYY 中未使用 XXX 的权重 意味着 YYY 未使用层 XXX，因此这些权重被丢弃。

如果模型权重的精度与基础模型相同（并且是受支持的模型），则无论 low_cpu_mem_usage 如何，权重都将使用 meta 设备延迟加载，并在输入通过该层后立即加载到内存中。

激活特殊的 “离线模式” 以在防火墙环境中使用此方法。

示例

>>> from transformers import BertConfig, BertModel

>>> # Download model and configuration from huggingface.co and cache.
>>> model = BertModel.from_pretrained("google-bert/bert-base-uncased")
>>> # Model was saved using *save_pretrained('./test/saved_model/')* (for example purposes, not runnable).
>>> model = BertModel.from_pretrained("./test/saved_model/")
>>> # Update configuration during loading.
>>> model = BertModel.from_pretrained("google-bert/bert-base-uncased", output_attentions=True)
>>> assert model.config.output_attentions == True
>>> # Loading from a TF checkpoint file instead of a PyTorch model (slower, for example purposes, not runnable).
>>> config = BertConfig.from_json_file("./tf_model/my_tf_model_config.json")
>>> model = BertModel.from_pretrained("./tf_model/my_tf_checkpoint.ckpt.index", from_tf=True, config=config)
>>> # Loading from a Flax checkpoint file instead of a PyTorch model (slower)
>>> model = BertModel.from_pretrained("google-bert/bert-base-uncased", from_flax=True)

low_cpu_mem_usage 算法

这是一个实验性功能，它使用大约 1 倍模型大小的 CPU 内存加载模型

以下是它的工作原理

保存我们拥有的 state_dict 键
在创建模型之前删除 state_dict，因为后者占用 1 倍模型大小的 CPU 内存
在模型实例化后，将要从加载的 state_dict 中替换的所有参数/缓冲区切换到 meta 设备
第二次加载 state_dict
从 state_dict 中替换参数/缓冲区

目前，它无法处理 deepspeed ZeRO stage 3 并忽略加载错误

get_input_embeddings

( ) → nn.Module

返回值

nn.Module

一个将词汇映射到隐藏状态的 PyTorch 模块。

返回模型的输入嵌入。

get_memory_footprint

( return_buffers = True )

参数

return_buffers (bool, 可选, 默认为 True) — 是否在计算内存占用量时返回缓冲区张量的大小。缓冲区是不需要梯度且未注册为参数的张量。例如，批量标准化层中的均值和标准差。请参阅： https://discuss.pytorch.org/t/what-pytorch-means-by-buffers/120266/2

获取模型的内存占用量。这将以字节为单位返回当前模型的内存占用量。这对于基准测试当前模型的内存占用量和设计一些测试很有用。解决方案的灵感来自 PyTorch 讨论： https://discuss.pytorch.org/t/gpu-memory-that-model-uses/56822/2

get_output_embeddings

( ) → nn.Module

返回值

nn.Module

一个将隐藏状态映射到词汇的 PyTorch 模块。

返回模型的输出嵌入。

gradient_checkpointing_disable

( )

停用当前模型的梯度检查点。

请注意，在其他框架中，此功能可能被称为“激活检查点”或“检查点激活”。

gradient_checkpointing_enable

( gradient_checkpointing_kwargs = None )

参数

gradient_checkpointing_kwargs (dict, 可选) — 传递给 torch.utils.checkpoint.checkpoint 函数的附加关键字参数。

激活当前模型的梯度检查点。

请注意，在其他框架中，此功能可能被称为“激活检查点”或“检查点激活”。

我们传递模块的 __call__ 方法而不是 forward，因为 __call__ 附加了模块的所有钩子。 https://discuss.pytorch.org/t/any-different-between-model-input-and-model-forward-input/3690/2

init_weights

( )

如果需要，修剪并可能初始化权重。如果使用自定义的 PreTrainedModel，则需要在 _init_weights 中实现任何初始化逻辑。

post_init

( )

在每个 Transformer 模型初始化结束时执行的方法，用于执行需要模型模块正确初始化的代码（例如权重初始化）。

prune_heads

( heads_to_prune: Dict )

参数

heads_to_prune (Dict[int, List[int]]) — 包含所选层索引（int）作为键的字典，以及与所述层中要修剪的头部列表（int 列表）关联的值。例如，{1: [0, 2], 2: [2, 3]} 将修剪第 1 层上的头部 0 和 2，以及第 2 层上的头部 2 和 3。

修剪基础模型的头部。

register_for_auto_class

( auto_class = 'AutoModel' )

参数

auto_class (str 或 type, 可选, 默认为 "AutoModel") — 要将此新模型注册到的自动类。

将此类注册到给定的自动类。这应该只用于自定义模型，因为库中的模型已经映射到自动类。

此 API 处于实验阶段，在下一版本中可能会有一些细微的突破性变化。

resize_token_embeddings

( new_num_tokens: Optional = None pad_to_multiple_of: Optional = None ) → torch.nn.Embedding

参数

new_num_tokens (int, 可选) — 嵌入矩阵中新的标记数量。增加大小将在末尾添加新初始化的向量。减小大小将从末尾删除向量。如果未提供或为 None，则仅返回指向模型的输入标记 torch.nn.Embedding 模块的指针，而不执行任何操作。
pad_to_multiple_of (int, 可选) — 如果设置，则将嵌入矩阵填充到所提供值的倍数。如果 new_num_tokens 设置为 None，则只会将嵌入填充到 pad_to_multiple_of 的倍数。

这对于在具有计算能力 >= 7.5（Volta）的 NVIDIA 硬件上或在受益于序列长度为 128 的倍数的 TPU 上启用 Tensor Core 的使用特别有用。有关这方面的更多详细信息，或有关选择正确大小调整值的帮助，请参阅本指南： https://docs.nvda.net.cn/deeplearning/performance/dl-performance-matrix-multiplication/index.html#requirements-tc

返回值

torch.nn.Embedding

指向模型的输入标记嵌入模块的指针。

如果 new_num_tokens != config.vocab_size，则调整模型的输入标记嵌入矩阵的大小。

如果模型类具有 tie_weights() 方法，则在之后处理权重嵌入的绑定。

reverse_bettertransformer

( ) → PreTrainedModel

返回值

PreTrainedModel

模型转换回原始建模。

还原to_bettertransformer() 的转换，以便使用原始建模，例如为了保存模型。

save_pretrained

( save_directory: Union is_main_process: bool = True state_dict: Optional = None save_function: Callable = <function save at 0x7f533ea92290> push_to_hub: bool = False max_shard_size: Union = '5GB' safe_serialization: bool = True variant: Optional = None token: Union = None save_peft_format: bool = True **kwargs )

参数

save_directory (str 或 os.PathLike) — 保存到的目录。如果不存在，将创建该目录。
is_main_process (bool, 可选, 默认为 True) — 调用此函数的进程是否是主进程。在像 TPU 这样的分布式训练中很有用，并且需要在所有进程上调用此函数。在这种情况下，仅在主进程上设置 is_main_process=True 以避免竞争条件。
state_dict (torch.Tensor 的嵌套字典) — 要保存的模型的状态字典。将默认为 self.state_dict()，但可以用于仅保存模型的一部分，或者在恢复模型的状态字典时需要采取特殊预防措施时（例如使用模型并行时）。
save_function (Callable) — 用于保存状态字典的函数。在需要用其他方法替换 torch.save 的分布式训练（如 TPU）中很有用。
push_to_hub (bool, 可选, 默认为 False) — 保存模型后是否将其推送到 Hugging Face 模型中心。您可以使用 repo_id 指定要推送到的仓库（默认为您的命名空间中的 save_directory 的名称）。
max_shard_size (int 或 str, 可选, 默认为 "5GB") — 检查点分片前的最大大小。然后，每个检查点分片的大小都将小于此大小。如果表示为字符串，则需要是数字后跟一个单位（例如 "5MB"）。我们将其默认为 5GB，以便模型能够在免费层的 Google Colab 实例上轻松运行，而不会出现 CPU OOM 问题。

如果模型的单个权重大于 max_shard_size，它将在其自己的检查点分片中，该分片将大于 max_shard_size。
safe_serialization (bool, 可选, 默认为 True) — 是否使用 safetensors 或传统的 PyTorch 方法（使用 pickle）保存模型。
variant (str, 可选) — 如果指定，则权重将以 pytorch_model..bin 格式保存。
token (str 或 bool, 可选) — 用作远程文件 HTTP 持有者授权的令牌。如果为 True 或未指定，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。
save_peft_format (bool, 可选, 默认为 True) — 为了与 PEFT 库向后兼容，如果适配器权重附加到模型，则适配器状态字典的所有键都需要以 base_model.model 作为前缀。高级用户可以通过将 save_peft_format 设置为 False 来禁用此行为。
kwargs (Dict[str, Any], 可选) — 传递给 push_to_hub() 方法的附加关键字参数。

将模型及其配置文件保存到目录中，以便可以使用 from_pretrained() 类方法重新加载它。

set_input_embeddings

( value: Module )

参数

value (nn.Module) — 将词汇表映射到隐藏状态的模块。

设置模型的输入嵌入。

tie_weights

( )

绑定输入嵌入和输出嵌入之间的权重。

如果在配置中设置了 torchscript 标志，则无法处理参数共享，因此我们改为克隆权重。

to_bettertransformer

( ) → PreTrainedModel

返回值

PreTrainedModel

转换为 BetterTransformer 的模型。

将模型转换为使用 PyTorch 的原生注意力实现，通过 Optimum 库集成到 Transformers 中。仅支持所有 Transformers 模型的一个子集。

PyTorch 的注意力快速路径允许通过内核融合和使用嵌套张量来加速推理。详细的基准测试可以在这篇博文中找到。

warn_if_padding_and_no_attention_mask

( input_ids attention_mask )

如果 input_ids 似乎包含填充但未提供注意力掩码，则显示一次性警告。

自定义模型也应该包含一个 _supports_assign_param_buffer，它决定了超级快速初始化是否可以应用于特定模型。如果 test_save_and_load_from_pretrained 失败，则表明您的模型需要此功能。如果是这样，请将其设置为 False。

ModuleUtilsMixin

类 transformers.modeling_utils.ModuleUtilsMixin

( )

torch.nn.Modules 的一些实用程序，用作混入。

add_memory_hooks

( )

在每个子模块正向传递之前和之后添加一个内存钩子，以记录内存消耗的增加。

内存消耗的增加存储在每个模块的 mem_rss_diff 属性中，可以使用 model.reset_memory_hooks_state() 将其重置为零。

estimate_tokens

( input_dict: Dict ) → int

参数

inputs (dict) — 模型输入。

返回值

int

令牌总数。

辅助函数，用于根据模型输入估算令牌总数。

floating_point_ops

( input_dict: Dict exclude_embeddings: bool = True ) → int

参数

batch_size (int) — 前向传递的批量大小。
sequence_length (int) — 批量中每行的标记数。
exclude_embeddings (bool, 可选, 默认为 True) — 是否计算嵌入和 softmax 操作。

返回值

int

浮点运算次数。

获取使用此 Transformer 模型进行批量前向和反向传递的（可选的，非嵌入）浮点运算次数。默认近似忽略了对标记数量的二次依赖性（如果 12 * d_model << sequence_length 则有效），如这篇论文第 2.1 节所述。对于具有参数重用的 Transformer（例如 Albert 或 Universal Transformers），或者如果使用非常高的序列长度进行远程建模，则应覆盖此方法。

get_extended_attention_mask

( attention_mask: Tensor input_shape: Tuple device: device = None dtype: torch.float32 = None )

参数

attention_mask (torch.Tensor) — 掩码，其中 1 表示要关注的标记，0 表示要忽略的标记。
input_shape (Tuple[int]) — 模型输入的形状。

使注意力和因果掩码可广播，以便忽略未来和被掩码的标记。

get_head_mask

( head_mask: Optional num_hidden_layers: int is_attention_chunked: bool = False )

参数

head_mask (torch.Tensor 形状为 [num_heads] 或 [num_hidden_layers x num_heads], 可选) — 指示是否保留头的掩码（1.0 表示保留，0.0 表示丢弃）。
num_hidden_layers (int) — 模型中隐藏层的数量。
is_attention_chunked (bool, 可选, 默认为 False) — 注意力分数是否按块计算。

如果需要，准备头部掩码。

invert_attention_mask

( encoder_attention_mask: Tensor ) → torch.Tensor

参数

encoder_attention_mask (torch.Tensor) — 注意力掩码。

返回值

torch.Tensor

反转后的注意力掩码。

反转注意力掩码（例如，切换 0 和 1）。

num_parameters

( only_trainable: bool = False exclude_embeddings: bool = False ) → int

参数

only_trainable (bool, 可选, 默认为 False) — 是否仅返回可训练参数的数量
exclude_embeddings (bool, 可选, 默认为 False) — 是否仅返回非嵌入参数的数量

返回值

int

参数数量。

获取模块中（可选地，可训练或非嵌入）参数的数量。

reset_memory_hooks_state

( )

重置每个模块的 mem_rss_diff 属性（参见 add_memory_hooks()）。

TFPreTrainedModel

类 transformers.TFPreTrainedModel

( config *inputs **kwargs )

所有 TF 模型的基类。

TFPreTrainedModel 负责存储模型的配置，并处理加载、下载和保存模型的方法，以及所有模型共有的一些方法，以

调整输入嵌入的大小，
在自注意力头中修剪头。

类属性（由派生类覆盖）

config_class (PretrainedConfig) — 用作此模型架构的配置类的 PretrainedConfig 的子类。
base_model_prefix (str) — 一个字符串，指示在相同架构的派生类中与基础模型关联的属性，这些派生类在基础模型之上添加了模块。
main_input_name (str) — 模型主要输入的名称（对于 NLP 模型通常为 input_ids，对于视觉模型为 pixel_values，对于语音模型为 input_values）。

push_to_hub

( repo_id: str use_temp_dir: Optional[bool] = None commit_message: Optional[str] = None private: Optional[bool] = None max_shard_size: Optional[Union[int, str]] = '10GB' token: Optional[Union[bool, str]] = None use_auth_token: Optional[Union[bool, str]] = None create_pr: bool = False **base_model_card_args )

参数

repo_id (str) — 您想要将模型推送到的仓库的名称。当推送到给定组织时，它应该包含您的组织名称。
use_temp_dir (bool, 可选) — 是否使用临时目录来存储保存的文件，然后再将其推送到 Hub。如果不存在名为 repo_id 的目录，则默认为 True，否则为 False。
commit_message (str, 可选) — 推送时提交的消息。默认为 "Upload model"。
private (bool, 可选) — 创建的仓库是否应该是私有的。
token (bool 或 str, 可选) — 用作远程文件 HTTP Bearer 授权的令牌。如果为 True，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。如果未指定 repo_url，则默认为 True。
max_shard_size (int 或 str，可选，默认为 "10GB") — 仅适用于模型。检查点分片前的最大大小。然后，每个检查点分片的大小都将小于此大小。如果表示为字符串，则需要是数字后跟单位（例如 "5MB"）。
create_pr (bool，可选，默认为 False) — 是否使用上传的文件创建 PR 或直接提交。

将模型文件上传到 🤗 模型中心，同时同步 repo_path_or_name 中仓库的本地克隆。

示例

from transformers import TFAutoModel

model = TFAutoModel.from_pretrained("google-bert/bert-base-cased")

# Push the model to your namespace with the name "my-finetuned-bert".
model.push_to_hub("my-finetuned-bert")

# Push the model to an organization with the name "my-finetuned-bert".
model.push_to_hub("huggingface/my-finetuned-bert")

can_generate

( ) → bool

返回值

bool

此模型是否可以使用 .generate() 生成序列。

返回此模型是否可以使用 .generate() 生成序列。

编译

( optimizer = 'rmsprop' loss = 'auto_with_warning' metrics = None loss_weights = None weighted_metrics = None run_eagerly = None steps_per_execution = None **kwargs )

这是一个简单的包装器，如果用户没有自己指定损失函数，它会将模型的损失输出头设置为损失。

创建模型卡片

( output_dir model_name: str language: Optional[str] = None license: Optional[str] = None tags: Optional[str] = None finetuned_from: Optional[str] = None tasks: Optional[str] = None dataset_tags: Optional[Union[str, List[str]]] = None dataset: Optional[Union[str, List[str]]] = None dataset_args: Optional[Union[str, List[str]]] = None )

参数

output_dir (str 或 os.PathLike) — 用于创建模型卡片的文件夹。
model_name (str, 可选) — 模型的名称。
language (str, 可选) — 模型的语言（如果适用）。
license (str, 可选) — 模型的许可证。如果提供给 Trainer 的原始模型来自 Hub 上的仓库，则默认为所用预训练模型的许可证。
tags (str 或 List[str], 可选) — 要包含在模型卡片元数据中的一些标签。
finetuned_from (str, 可选) — 用于微调此模型的模型名称（如果适用）。默认为提供给 Trainer 的原始模型的仓库名称（如果它来自 Hub）。
tasks (str 或 List[str], 可选) — 一个或多个任务标识符，将包含在模型卡片的元数据中。
dataset_tags (str 或 List[str]，可选) — 一个或多个数据集标签，将包含在模型卡片的元数据中。
dataset (str 或 List[str]，可选) — 一个或多个数据集标识符，将包含在模型卡片的元数据中。
dataset_args (str 或 List[str]，可选) — 一个或多个数据集参数，将包含在模型卡片的元数据中。

使用 Trainer 可用的信息创建模型卡片草稿。

from_pretrained

( pretrained_model_name_or_path: Optional[Union[str, os.PathLike]] *model_args config: Optional[Union[PretrainedConfig, str, os.PathLike]] = None cache_dir: Optional[Union[str, os.PathLike]] = None ignore_mismatched_sizes: bool = False force_download: bool = False local_files_only: bool = False token: Optional[Union[str, bool]] = None revision: str = 'main' use_safetensors: bool = None **kwargs )

参数

pretrained_model_name_or_path (str，可选) — 可以是以下之一：
- 一个字符串，表示 huggingface.co 上模型仓库中托管的预训练模型的 *模型 ID*。
- 一个 *目录* 的路径，其中包含使用 save_pretrained() 保存的模型权重，例如 ./my_model_directory/。
- 一个 *PyTorch state_dict 保存文件* 的路径或 URL（例如 ./pt_model/pytorch_model.bin）。在这种情况下，from_pt 应设置为 True，并且应提供一个配置对象作为 config 参数。此加载路径比使用提供的转换脚本将 PyTorch 模型转换为 TensorFlow 模型，然后再加载 TensorFlow 模型要慢。
- 如果您同时提供配置和状态字典（分别使用关键字参数 config 和 state_dict），则为 None。
model_args (位置参数序列，可选) — 所有剩余的位置参数将传递给底层模型的 __init__ 方法。
config (Union[PretrainedConfig, str], 可选) — 可以是：
- 派生自 PretrainedConfig 的类的实例，
- 一个作为 from_pretrained() 输入有效的字符串。
用于模型的配置，而不是自动加载的配置。配置可以在以下情况下自动加载：
- 模型是由库提供的模型（使用预训练模型的*模型 ID*字符串加载）。
- 模型是使用 save_pretrained() 保存的，并通过提供保存目录重新加载。
- 模型是通过提供本地目录作为 pretrained_model_name_or_path 加载的，并且在目录中找到了名为 *config.json* 的配置 JSON 文件。
from_pt (bool, 可选, 默认为 False) — 从 PyTorch state_dict 保存文件加载模型权重（请参阅 pretrained_model_name_or_path 参数的文档字符串）。
ignore_mismatched_sizes (bool, 可选, 默认为 False) — 如果检查点中某些权重的尺寸与模型的权重尺寸不匹配（例如，您正在从具有 3 个标签的检查点实例化具有 10 个标签的模型），是否引发错误。
cache_dir (str, 可选) — 如果不应使用标准缓存，则为下载的预训练模型配置应缓存到的目录的路径。
force_download (bool, 可选, 默认为 False) — 是否强制（重新）下载模型权重和配置文件，覆盖缓存版本（如果存在）。resume_download — 已弃用并忽略。现在，所有下载都将在可能的情况下默认恢复。将在 Transformers 的 v5 版本中删除。proxies — (Dict[str, str], 可选): 按协议或端点使用的代理服务器字典，例如，{‘http’: ‘foo.bar:3128’, ‘http://hostname’: ‘foo.bar:4012’}。代理在每个请求上使用。output_loading_info(bool, *可选*, 默认为 False`): 是否也返回包含缺失键、意外键和错误消息的字典。
local_files_only(bool, 可选，默认为 False) — 是否仅查看本地文件（例如，不尝试下载模型）。
token (str 或 bool，可选) — 用于远程文件的 HTTP Bearer 授权令牌。如果为 True 或未指定，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。
revision (str，可选，默认为 "main") — 要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID，因为我们使用基于 git 的系统在 huggingface.co 上存储模型和其他工件，因此 revision 可以是 git 允许的任何标识符。

从预训练模型配置实例化一个预训练的 TF 2.0 模型。

警告 XXX 的权重未从预训练模型初始化 意味着 XXX 的权重没有与模型的其余部分一起预训练。您可以使用下游微调任务来训练这些权重。

警告 YYY 中未使用 XXX 的权重 意味着 YYY 未使用层 XXX，因此这些权重被丢弃。

示例

>>> from transformers import BertConfig, TFBertModel

>>> # Download model and configuration from huggingface.co and cache.
>>> model = TFBertModel.from_pretrained("google-bert/bert-base-uncased")
>>> # Model was saved using *save_pretrained('./test/saved_model/')* (for example purposes, not runnable).
>>> model = TFBertModel.from_pretrained("./test/saved_model/")
>>> # Update configuration during loading.
>>> model = TFBertModel.from_pretrained("google-bert/bert-base-uncased", output_attentions=True)
>>> assert model.config.output_attentions == True
>>> # Loading from a Pytorch model file instead of a TensorFlow checkpoint (slower, for example purposes, not runnable).
>>> config = BertConfig.from_json_file("./pt_model/my_pt_model_config.json")
>>> model = TFBertModel.from_pretrained("./pt_model/my_pytorch_model.bin", from_pt=True, config=config)

获取偏置

( ) → tf.Variable

返回值

tf.Variable

表示偏置的权重，如果不是 LM 模型则为 None。

附加到 LM 头部的偏置字典。键表示偏置属性的名称。

get_head_mask

( head_mask: tf.Tensor | None num_hidden_layers: int )

参数

head_mask (形状为 [num_heads] 或 [num_hidden_layers x num_heads] 的 tf.Tensor，可选) — 指示是否保留头的掩码（1.0 表示保留，0.0 表示丢弃）。
num_hidden_layers (int) — 模型中隐藏层的数量。

如果需要，准备头部掩码。

get_input_embeddings

( ) → tf.Variable

返回值

tf.Variable

将词汇映射到隐藏状态的嵌入层。

返回模型的输入嵌入层。

get_lm_head

( ) → keras.layers.Layer

返回值

keras.layers.Layer

如果模型有 LM 头层，则返回该层；如果没有，则返回 None。

LM 头层。所有具有 LM 头的模型都必须重写此方法。

get_output_embeddings

( ) → tf.Variable

返回值

tf.Variable

将词汇映射到隐藏状态的新权重。

返回模型的输出嵌入

get_output_layer_with_bias

( ) → keras.layers.Layer

返回值

keras.layers.Layer

处理偏差的层，如果不是 LM 模型，则为 None。

获取处理偏差属性的层，以防模型具有与嵌入绑定的权重的 LM 头

get_prefix_bias_name

( ) → str

返回值

str

偏差的 _prefix 名称。

从模型名称到父层的偏差的拼接 _prefix 名称

prepare_tf_dataset

( dataset: 'datasets.Dataset' batch_size: int = 8 shuffle: bool = True tokenizer: Optional['PreTrainedTokenizerBase'] = None collate_fn: Optional[Callable] = None collate_fn_args: Optional[Dict[str, Any]] = None drop_remainder: Optional[bool] = None prefetch: bool = True ) → Dataset

参数

dataset (Any) — 将被包装为 tf.data.Dataset 的 [~datasets.Dataset]。
batch_size (int, 可选, 默认为 8) — 返回的批次大小。
shuffle (bool, 默认为 True) — 是否以随机顺序从数据集中返回样本。通常对于训练数据集为 True，对于验证/测试数据集为 False。
tokenizer (PreTrainedTokenizerBase, 可选) — 将用于填充样本以创建批次的 PreTrainedTokenizer。如果传递了特定的 collate_fn，则没有效果。
collate_fn (Callable, 可选) — 一个将数据集中的样本整理成单个批次的函数。如果没有提供 tokenizer，则默认为 DefaultDataCollator；如果传递了 tokenizer，则默认为 DataCollatorWithPadding。
collate_fn_args (Dict[str, Any], 可选) — 要与样本列表一起传递给 collate_fn 的参数字典。
drop_remainder (bool, 可选) — 是否丢弃最后一个批次，如果 batch_size 不能均匀地划分数据集长度。默认为与 shuffle 相同的设置。
prefetch (bool, 默认为 True) — 是否在 tf.data 管道的末尾添加预取。这几乎总是有益于性能，但在边缘情况下可以禁用。

返回值

数据集

一个 tf.data.Dataset，它已准备好传递给 Keras API。

将 HuggingFace 数据集包装为 tf.data.Dataset，并进行整理和批处理。此方法旨在创建一个“随时可用”的数据集，可以直接传递给 Keras 方法（如 fit()），而无需进一步修改。如果数据集中的列与模型的输入名称不匹配，该方法将从数据集中删除这些列。如果您想指定要返回的列名，而不是使用与此模型匹配的名称，我们建议您使用 Dataset.to_tf_dataset()。

prune_heads

( heads_to_prune )

参数

heads_to_prune (Dict[int, List[int]]) — 字典，键是选定的层索引 (int)，关联的值是要在该层中修剪的头的列表（int 列表）。例如 {1: [0, 2], 2: [2, 3]} 将修剪第 1 层的 0 和 2 号头，以及第 2 层的 2 和 3 号头。

修剪基础模型的头部。

register_for_auto_class

( auto_class = 'TFAutoModel' )

参数

auto_class (str 或 type, 可选, 默认为 "TFAutoModel") — 将此新模型注册到的自动类。

将此类注册到给定的自动类。这应该只用于自定义模型，因为库中的模型已经映射到自动类。

此 API 处于实验阶段，在下一版本中可能会有一些细微的突破性变化。

resize_token_embeddings

( new_num_tokens: Optional[int] = None ) → tf.Variable 或 keras.layers.Embedding

参数

new_num_tokens (int, 可选) — 嵌入矩阵中新标记的数量。增加大小将在末尾添加新初始化的向量。减小大小将从末尾删除向量。如果未提供或为 None，则仅返回指向输入标记的指针，而不执行任何操作。

返回值

tf.Variable 或 keras.layers.Embedding

指向模型输入标记的指针。

如果 new_num_tokens != config.vocab_size，则调整模型的输入标记嵌入矩阵的大小。

如果模型类具有 tie_weights() 方法，则在之后处理权重嵌入的绑定。

save_pretrained

( save_directory saved_model = False version = 1 push_to_hub = False signatures = None max_shard_size: Union[int, str] = '5GB' create_pr: bool = False safe_serialization: bool = False token: Optional[Union[str, bool]] = None **kwargs )

参数

save_directory (str) — 要保存到的目录。如果不存在，将创建该目录。
saved_model (bool, 可选, 默认为 False) — 模型是否也必须以保存的模型格式保存。
version (int，可选，默认为 1) — 已保存模型的版本。为了能够被 TensorFlow Serving 正确加载，已保存的模型需要进行版本控制，如官方文档 https://tensorflowcn.cn/tfx/serving/serving_basic 中所述。
push_to_hub (bool，可选，默认为 False) — 保存模型后是否将其推送到 Hugging Face 模型中心。您可以使用 repo_id 指定要推送到的仓库（默认为您的命名空间中的 save_directory 名称）。
signatures (dict 或 tf.function，可选) — 用于服务的模型签名。这将被传递给 model.save() 的 signatures 参数。
max_shard_size (int 或 str，可选，默认为 "10GB") — 检查点分片前的最大大小。然后，每个检查点分片的大小都将小于此大小。如果表示为字符串，则需要是数字后跟一个单位（例如 "5MB"）。

如果模型的单个权重大于 max_shard_size，它将在其自己的检查点分片中，该分片将大于 max_shard_size。
create_pr (bool，可选，默认为 False) — 是否使用上传的文件创建 PR 或直接提交。
safe_serialization (bool，可选，默认为 False) — 是否使用 safetensors 或传统的 TensorFlow 方式（使用 h5）保存模型。
token (str 或 bool，可选) — 用于远程文件的 HTTP Bearer 授权的令牌。如果为 True 或未指定，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。
kwargs (Dict[str, Any]，可选) — 传递给 push_to_hub() 方法的附加关键字参数。

将模型及其配置文件保存到目录中，以便可以使用 from_pretrained() 类方法重新加载它。

serving

( inputs )

参数

用于服务模型的方法。没有特定的签名，但会被具体化 —
使用 save_pretrained 保存时的函数。 — inputs (Dict[str, tf.Tensor]): 已保存模型的输入，作为张量字典。

serving_output

( output )

准备保存模型的输出。如果需要特定的服务修改，可以重写。

set_bias

( value )

参数

value (Dict[tf.Variable]) — 附加到 LM 头的所有新偏差。

设置 LM 头中的所有偏差。

set_input_embeddings

( value )

参数

value (tf.Variable) — 将隐藏状态映射到词汇表的新权重。

设置模型的输入嵌入

set_output_embeddings

( value )

参数

value (tf.Variable) — 将隐藏状态映射到词汇表的新权重。

设置模型的输出嵌入

test_step

( data )

对 Keras 默认的 train_step 的修改，它可以正确地将模型的输出与标签进行匹配，并支持直接在损失输出头上进行训练。此外，它确保在适当的情况下将输入键复制到标签。在使用虚拟损失时，它还会将标签键复制到输入字典中，以确保模型在正向传递期间可以访问它们。

train_step

( data )

对 Keras 默认的 train_step 的修改，它可以正确地将模型的输出与标签进行匹配，并支持直接在损失输出头上进行训练。此外，它确保在适当的情况下将输入键复制到标签。在使用虚拟损失时，它还会将标签键复制到输入字典中，以确保模型在正向传递期间可以访问它们。

TFModelUtilsMixin

类 transformers.modeling_tf_utils.TFModelUtilsMixin

( )

keras.Model 的一些实用程序，用作混入。

num_parameters

( only_trainable: bool = False ) → int

参数

only_trainable (bool, 可选, 默认为 False) — 是否仅返回可训练参数的数量

返回值

int

参数数量。

获取模型中（可选，可训练的）参数的数量。

FlaxPreTrainedModel

类 transformers.FlaxPreTrainedModel

( config: PretrainedConfig module: Module input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True )

所有模型的基类。

FlaxPreTrainedModel 负责存储模型的配置，并处理加载、下载和保存模型的方法。

类属性（由派生类覆盖）

config_class (PretrainedConfig) — 用作此模型架构的配置类的 PretrainedConfig 的子类。
base_model_prefix (str) — 一个字符串，指示在相同架构的派生类中与基础模型关联的属性，这些派生类在基础模型之上添加了模块。
main_input_name (str) — 模型主要输入的名称（对于 NLP 模型通常为 input_ids，对于视觉模型为 pixel_values，对于语音模型为 input_values）。

push_to_hub

( repo_id: str use_temp_dir: Optional = None commit_message: Optional = None private: Optional = None token: Union = None max_shard_size: Union = '5GB' create_pr: bool = False safe_serialization: bool = True revision: str = None commit_description: str = None tags: Optional = None **deprecated_kwargs )

参数

repo_id (str) — 您要将模型推送到哪个仓库的名称。当推送到给定组织时，它应该包含您的组织名称。
use_temp_dir (bool，可选) — 是否使用临时目录来存储保存的文件，然后再将其推送到 Hub。如果不存在名为 repo_id 的目录，则默认为 True，否则默认为 False。
commit_message (str，可选) — 推送时提交的消息。默认为 "Upload model"。
private (bool，可选) — 创建的存储库是否应该是私有的。
token (bool 或 str，可选) — 用作远程文件 HTTP 持有者授权的令牌。如果为 True，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。如果未指定 repo_url，则默认为 True。
max_shard_size (int 或 str，可选，默认为 "5GB") — 仅适用于模型。检查点分片前的最大大小。然后，每个检查点分片的大小都将小于此大小。如果表示为字符串，则需要是数字后跟一个单位（例如 "5MB"）。我们将其默认为 "5GB"，以便用户可以在免费层的 Google Colab 实例上轻松加载模型，而不会出现任何 CPU OOM 问题。
create_pr (bool，可选，默认为 False) — 是否使用上传的文件创建 PR 或直接提交。
safe_serialization (bool，可选，默认为 True) — 是否将模型权重转换为更安全的序列化格式 safetensors。
revision (str，可选) — 要将上传的文件推送到哪个分支。
commit_description (str，可选) — 将创建的提交的描述
tags (List[str]，可选) — 要推送到 Hub 的标签列表。

将模型检查点上传到 🤗 模型中心。

示例

from transformers import FlaxAutoModel

model = FlaxAutoModel.from_pretrained("google-bert/bert-base-cased")

# Push the model to your namespace with the name "my-finetuned-bert".
model.push_to_hub("my-finetuned-bert")

# Push the model to an organization with the name "my-finetuned-bert".
model.push_to_hub("huggingface/my-finetuned-bert")

can_generate

( )

返回此模型是否可以使用 .generate() 生成序列。返回值： bool：此模型是否可以使用 .generate() 生成序列。

from_pretrained

( pretrained_model_name_or_path: Union dtype: dtype = <class 'jax.numpy.float32'> *model_args config: Union = None cache_dir: Union = None ignore_mismatched_sizes: bool = False force_download: bool = False local_files_only: bool = False token: Union = None revision: str = 'main' **kwargs )

参数

pretrained_model_name_or_path (str 或 os.PathLike) — 可以是以下几种:
- 一个字符串，表示 huggingface.co 上模型库中托管的预训练模型的 模型 ID。
- 一个指向目录的路径，该目录包含使用 save_pretrained() 保存的模型权重，例如 ./my_model_directory/。
- 一个指向 pt 索引检查点文件 的路径或 URL（例如 ./tf_model/model.ckpt.index）。在这种情况下，from_pt 应设置为 True。
dtype (jax.numpy.dtype, 可选, 默认为 jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32、jax.numpy.float16（在 GPU 上）和 jax.numpy.bfloat16（在 TPU 上）之一。

这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算都将使用给定的 dtype 执行。

请注意，这仅指定计算的 dtype，不会影响模型参数的 dtype。

如果您希望更改模型参数的 dtype，请参阅 to_fp16() 和 to_bf16()。
model_args (位置参数序列, 可选) — 所有剩余的位置参数将传递给底层模型的 __init__ 方法。
config (Union[PretrainedConfig, str, os.PathLike], 可选) — 可以是以下几种:
- 派生自 PretrainedConfig 的类的实例，
- 一个字符串或路径，作为 from_pretrained() 的有效输入。
要使用的模型配置，而不是自动加载的配置。配置可以在以下情况下自动加载：
- 模型是由库提供的模型（使用预训练模型的 模型 ID 字符串加载）。
- 模型是使用 save_pretrained() 保存的，并通过提供保存目录重新加载。
- 模型是通过提供本地目录作为 pretrained_model_name_or_path 加载的，并且在目录中找到了名为 config.json 的配置 JSON 文件。
cache_dir (Union[str, os.PathLike], 可选) — 如果不应使用标准缓存，则指向应在其中缓存下载的预训练模型配置的目录的路径。
from_pt (bool，可选，默认为 False) — 从 PyTorch 检查点保存文件加载模型权重（请参阅 pretrained_model_name_or_path 参数的文档字符串）。
ignore_mismatched_sizes (bool，可选，默认为 False) — 如果检查点中某些权重的尺寸与模型的权重尺寸不匹配（例如，如果您正在从具有 3 个标签的检查点实例化具有 10 个标签的模型），是否引发错误。
force_download (bool，可选，默认为 False) — 是否强制（重新）下载模型权重和配置文件，覆盖缓存版本（如果存在）。resume_download — 已弃用并忽略。现在，所有下载都将在可能的情况下默认恢复。将在 Transformers v5 中移除。
proxies (Dict[str, str]，可选) — 要按协议或端点使用的代理服务器字典，例如，{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}。代理用于每个请求。
local_files_only(bool，可选，默认为 False) — 是否仅查看本地文件（即，不尝试下载模型）。
token (str 或 bool，可选) — 用作远程文件 HTTP 持有者授权的令牌。如果为 True 或未指定，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。
revision (str，可选，默认为 "main") — 要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID，因为我们使用基于 git 的系统在 huggingface.co 上存储模型和其他工件，所以 revision 可以是 git 允许的任何标识符。

从预训练模型配置实例化预训练的 flax 模型。

警告 XXX 的权重未从预训练模型初始化 意味着 XXX 的权重没有与模型的其余部分一起预训练。您可以使用下游微调任务来训练这些权重。

警告 YYY 中未使用 XXX 的权重 意味着 YYY 未使用层 XXX，因此这些权重被丢弃。

示例

>>> from transformers import BertConfig, FlaxBertModel

>>> # Download model and configuration from huggingface.co and cache.
>>> model = FlaxBertModel.from_pretrained("google-bert/bert-base-cased")
>>> # Model was saved using *save_pretrained('./test/saved_model/')* (for example purposes, not runnable).
>>> model = FlaxBertModel.from_pretrained("./test/saved_model/")
>>> # Loading from a PyTorch checkpoint file instead of a PyTorch model (slower, for example purposes, not runnable).
>>> config = BertConfig.from_json_file("./pt_model/config.json")
>>> model = FlaxBertModel.from_pretrained("./pt_model/pytorch_model.bin", from_pt=True, config=config)

加载分片 Flax 权重

( shard_files ) → Dict

参数

shard_files (List[str] — 要加载的碎片文件列表。

返回值

Dict

模型参数的嵌套字典，采用 flax 模型的预期格式：{'model': {'params': {'...'}}}。

这与 flax.serialization.from_bytes (https:lax.readthedocs.io/en/latest/_modules/flax/serialization.html#from_bytes) 相同，但用于分片检查点。

此加载过程高效执行：每个检查点碎片依次加载到 RAM 中，并在加载到模型后删除。

register_for_auto_class

( auto_class = 'FlaxAutoModel' )

参数

auto_class (str 或 type，可选，默认为 "FlaxAutoModel") — 将此新模型注册到的自动类。

将此类注册到给定的自动类。这应该只用于自定义模型，因为库中的模型已经映射到自动类。

此 API 处于实验阶段，在下一版本中可能会有一些细微的突破性变化。

save_pretrained

( save_directory: Union params = None push_to_hub = False max_shard_size = '10GB' token: Union = None safe_serialization: bool = False **kwargs )

参数

save_directory (str 或 os.PathLike) — 要保存到的目录。如果不存在，则会创建。
push_to_hub (bool，可选，默认为 False) — 保存模型后是否将其推送到 Hugging Face 模型中心。您可以使用 repo_id 指定要推送到的仓库（默认为您的命名空间中的 save_directory 名称）。
max_shard_size (int 或 str，可选，默认为 "10GB") — 检查点分片前的最大大小。然后，每个检查点分片的大小都将小于此大小。如果表示为字符串，则需要是数字后跟单位（例如 "5MB"）。

如果模型的单个权重大于 max_shard_size，则它将在其自己的检查点分片中，该分片将大于 max_shard_size。
token (str 或 bool，可选) — 用作远程文件 HTTP Bearer 授权的令牌。如果为 True 或未指定，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。
kwargs (Dict[str, Any]，可选) — 传递给 push_to_hub() 方法的附加关键字参数。
safe_serialization (bool，可选，默认为 False) — 是否使用 safetensors 或通过 msgpack 保存模型。

将模型及其配置文件保存到目录中，以便可以使用 [from_pretrained()](/docs/transformers/v4.45.2/en/main_classes/model#transformers.FlaxPreTrainedModel.from_pretrained) 类方法重新加载它

to_bf16

( params: Union mask: Any = None )

参数

params (Union[Dict, FrozenDict]) — 模型参数的 PyTree。
mask (Union[Dict, FrozenDict]) — 与 params 树结构相同的 PyTree。叶子节点应为布尔值，对于要转换的参数为 True，对于要跳过的参数为 False。

将浮点 params 转换为 jax.numpy.bfloat16。这将返回一个新的 params 树，并且不会就地转换 params。

此方法可在 TPU 上使用，将模型参数显式转换为 bfloat16 精度，以进行全半精度训练或以 bfloat16 格式保存权重以进行推理，从而节省内存并提高速度。

示例

>>> from transformers import FlaxBertModel

>>> # load model
>>> model = FlaxBertModel.from_pretrained("google-bert/bert-base-cased")
>>> # By default, the model parameters will be in fp32 precision, to cast these to bfloat16 precision
>>> model.params = model.to_bf16(model.params)
>>> # If you want don't want to cast certain parameters (for example layer norm bias and scale)
>>> # then pass the mask as follows
>>> from flax import traverse_util

>>> model = FlaxBertModel.from_pretrained("google-bert/bert-base-cased")
>>> flat_params = traverse_util.flatten_dict(model.params)
>>> mask = {
...     path: (path[-2] != ("LayerNorm", "bias") and path[-2:] != ("LayerNorm", "scale"))
...     for path in flat_params
... }
>>> mask = traverse_util.unflatten_dict(mask)
>>> model.params = model.to_bf16(model.params, mask)

to_fp16

( params: Union mask: Any = None )

参数

params (Union[Dict, FrozenDict]) — 模型参数的 PyTree。
mask (Union[Dict, FrozenDict]) — 与 params 树结构相同的 PyTree。叶子节点应为布尔值，对于要转换的参数为 True，对于要跳过的参数为 False

将浮点 parmas 转换为 jax.numpy.float16。这将返回一个新的 params 树，并且不会就地转换 params。

此方法可在 GPU 上使用，将模型参数显式转换为 float16 精度，以进行全半精度训练或以 float16 格式保存权重以进行推理，从而节省内存并提高速度。

示例

>>> from transformers import FlaxBertModel

>>> # load model
>>> model = FlaxBertModel.from_pretrained("google-bert/bert-base-cased")
>>> # By default, the model params will be in fp32, to cast these to float16
>>> model.params = model.to_fp16(model.params)
>>> # If you want don't want to cast certain parameters (for example layer norm bias and scale)
>>> # then pass the mask as follows
>>> from flax import traverse_util

>>> model = FlaxBertModel.from_pretrained("google-bert/bert-base-cased")
>>> flat_params = traverse_util.flatten_dict(model.params)
>>> mask = {
...     path: (path[-2] != ("LayerNorm", "bias") and path[-2:] != ("LayerNorm", "scale"))
...     for path in flat_params
... }
>>> mask = traverse_util.unflatten_dict(mask)
>>> model.params = model.to_fp16(model.params, mask)

to_fp32

( params: Union mask: Any = None )

参数

params (Union[Dict, FrozenDict]) — 模型参数的 PyTree。
mask (Union[Dict, FrozenDict]) — 与 params 树结构相同的 PyTree。叶子节点应该是布尔值，对于要转换的参数为 True，对于要跳过的参数为 False

将浮点数 parmas 转换为 jax.numpy.float32。此方法可用于将模型参数显式转换为 fp32 精度。这将返回一个新的 params 树，并且不会就地转换 params。

示例

>>> from transformers import FlaxBertModel

>>> # Download model and configuration from huggingface.co
>>> model = FlaxBertModel.from_pretrained("google-bert/bert-base-cased")
>>> # By default, the model params will be in fp32, to illustrate the use of this method,
>>> # we'll first cast to fp16 and back to fp32
>>> model.params = model.to_f16(model.params)
>>> # now cast back to fp32
>>> model.params = model.to_fp32(model.params)

推送到 Hub

类 transformers.utils.PushToHubMixin

( )

包含将模型或分词器推送到 Hub 的功能的 Mixin。

push_to_hub

( repo_id: str use_temp_dir: Optional = None commit_message: Optional = None private: Optional = None token: Union = None max_shard_size: Union = '5GB' create_pr: bool = False safe_serialization: bool = True revision: str = None commit_description: str = None tags: Optional = None **deprecated_kwargs )

参数

repo_id (str) — 要将 {object} 推送到哪个仓库的名称。当推送到给定组织时，它应该包含您的组织名称。
use_temp_dir (bool, 可选) — 是否使用临时目录来存储保存的文件，然后再将其推送到 Hub。如果不存在名为 repo_id 的目录，则默认为 True，否则为 False。
commit_message (str, 可选) — 推送时提交的消息。默认为 "Upload {object}"。
private (bool，可选) — 创建的仓库是否应该是私有的。
token (bool 或 str，可选) — 用作远程文件 HTTP Bearer 授权的令牌。如果为 True，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。如果未指定 repo_url，则默认为 True。
max_shard_size (int 或 str，可选，默认为 "5GB") — 仅适用于模型。检查点分片前的最大大小。然后，每个检查点分片的大小都将小于此大小。如果表示为字符串，则需要是数字后跟单位（例如 "5MB"）。我们将其默认为 "5GB"，以便用户可以在免费层的 Google Colab 实例上轻松加载模型，而不会出现任何 CPU OOM 问题。
create_pr (bool，可选，默认为 False) — 是否使用上传的文件创建 PR 或直接提交。
safe_serialization (bool，可选，默认为 True) — 是否将模型权重转换为 safetensors 格式以进行更安全的序列化。
revision (str，可选) — 上传文件要推送到的分支。
commit_description (str，可选) — 将创建的提交的描述
tags (List[str]，可选) — 要推送到 Hub 的标签列表。

将 {object_files} 上传到 🤗 模型中心。

示例

from transformers import {object_class}

{object} = {object_class}.from_pretrained("google-bert/bert-base-cased")

# Push the {object} to your namespace with the name "my-finetuned-bert".
{object}.push_to_hub("my-finetuned-bert")

# Push the {object} to an organization with the name "my-finetuned-bert".
{object}.push_to_hub("huggingface/my-finetuned-bert")

分片检查点

transformers.modeling_utils.load_sharded_checkpoint

( model folder strict = True prefer_safe = True ) → NamedTuple

参数

model (torch.nn.Module) — 要加载检查点的模型。
folder (str 或 os.PathLike) — 包含分片检查点的文件夹的路径。
strict (bool, *可选, 默认为 True`) — 是否严格执行模型状态字典中的键与分片检查点中的键匹配。
prefer_safe (bool, *可选*, 默认为 False) — 如果检查点中同时存在 safetensors 和 PyTorch 保存文件，并且 prefer_safe 为 True，则将加载 safetensors 文件。否则，只要有可能，始终加载 PyTorch 文件。

返回值

NamedTuple

一个包含 missing_keys 和 unexpected_keys 字段的命名元组

missing_keys 是一个包含缺失键的 str 列表
unexpected_keys 是一个包含意外键的 str 列表

这与 torch.nn.Module.load_state_dict 相同，但用于分片检查点。

此加载过程高效执行：每个检查点碎片依次加载到 RAM 中，并在加载到模型后删除。

< > 在 GitHub 上更新

←日志记录文本生成→