Transformers

( 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: typing.Optional[bool] = None commit_message: typing.Optional[str] = None private: typing.Optional[bool] = None token: typing.Union[bool, str, NoneType] = None max_shard_size: typing.Union[str, int, NoneType] = '5GB' create_pr: bool = False safe_serialization: bool = True revision: typing.Optional[str] = None commit_description: typing.Optional[str] = None tags: typing.Optional[list[str]] = None **deprecated_kwargs )

参数

repo_id (str) — 您要将模型推送到存储库的名称。在推送到给定组织时，它应包含您的组织名称。
use_temp_dir (bool, 可选) — 是否使用临时目录来存储在推送到 Hub 之前保存的文件。如果没有名为 repo_id 的目录，则默认为 True，否则为 False。
commit_message (str, 可选) — 推送时提交的消息。默认为 "Upload model"。
private (bool, 可选) — 是否将存储库设为私有。如果为 None（默认），则存储库将是公开的，除非组织的默认设置为私有。如果存储库已存在，此值将被忽略。
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) — 是否使用上传文件创建拉取请求或直接提交。
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: typing.Union[list[str], str] )

参数

tags (Union[list[str], str]) — 要注入到模型中的所需标签

将自定义标签添加到推送到 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

布尔值

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

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

在底层，对于返回 True 的类，会触发一些特定于生成的更改：例如，模型实例将具有填充的 generation_config 属性。

dequantize

( )

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

disable_input_require_grads

( )

移除 _require_grads_hook。

enable_input_require_grads

( )

启用输入嵌入的梯度。这对于在保持模型权重不变的情况下微调适配器权重很有用。

from_pretrained

( pretrained_model_name_or_path: typing.Union[str, os.PathLike, NoneType] *model_args config: typing.Union[transformers.configuration_utils.PretrainedConfig, str, os.PathLike, NoneType] = None cache_dir: typing.Union[str, os.PathLike, NoneType] = None ignore_mismatched_sizes: bool = False force_download: bool = False local_files_only: bool = False token: typing.Union[str, bool, NoneType] = None revision: str = 'main' use_safetensors: typing.Optional[bool] = None weights_only: bool = True **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 模型要慢。
- 一个包含 *flax 检查点文件*（.msgpack 格式）的模型文件夹的路径或 URL（例如，包含 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) — 如果检查点中的某些权重与模型权重大小不匹配（例如，您正在实例化一个具有 10 个标签的模型，而检查点具有 3 个标签），是否引发错误。
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 持有者授权令牌。如果为 True 或未指定，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。
revision (str, 可选, 默认为 "main") — 要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID，因为我们使用基于 Git 的系统在 huggingface.co 上存储模型和其他工件，因此 revision 可以是 Git 允许的任何标识符。

要在 Hub 上测试您创建的拉取请求，您可以传递 revision="refs/pr/<pr_number>"。
attn_implementation (str, 可选) — 模型中要使用的注意力实现（如果相关）。可以是 "eager"（注意力的手动实现）、"sdpa"（使用 F.scaled_dot_product_attention）、"flash_attention_2"（使用 Dao-AILab/flash-attention）或 "flash_attention_3"（使用 Dao-AILab/flash-attention/hopper）。默认情况下，如果可用，对于 torch>=2.1.1 将使用 SDPA。否则默认是手动 "eager" 实现。

大型模型推理参数

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 加载模型。它不能用作模型训练方式的指标。因为它可能以半精度 dtype 训练，但以 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"，或像 1 这样的 GPU 顺序），则设备映射将整个模型映射到此设备。传递 device_map = 0 表示将整个模型放置在 GPU 0 上。

要让 Accelerate 自动计算最优化的 device_map，请设置 device_map="auto"。有关每个选项的更多信息，请参阅设计设备映射。
max_memory (Dict, 可选) — 如果使用 device_map，则是一个字典，将设备标识符映射到最大内存。如果未设置，将默认为每个 GPU 的最大可用内存和可用 CPU RAM。
tp_plan (str, 可选) — Torch 张量并行计划，请参阅此处。目前，它仅接受 tp_plan="auto" 以使用基于模型的预定义计划。请注意，如果您使用它，则应相应地使用 torchrun [args] script.py 启动脚本。这将比使用 device_map 快得多，但有局限性。
tp_size (str, 可选) — Torch 张量并行度。如果未提供，则默认为世界大小。
device_mesh (torch.distributed.DeviceMesh, 可选) — Torch 设备网格。如果未提供，则默认为世界大小。目前仅用于张量并行。
offload_folder (str 或 os.PathLike, 可选) — 如果 device_map 包含任何值 "disk"，则为我们将卸载权重的文件夹。
offload_state_dict (bool, 可选) — 如果为 True，将暂时将 CPU 状态字典卸载到硬盘驱动器，以避免在 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 上模型 repo 的子文件夹中，您可以在此处指定文件夹名称。
variant (str, 可选) — 如果指定，则从 variant 文件名加载权重，例如 pytorch_model..bin。在使用 from_tf 或 from_flax 时，variant 被忽略。
use_safetensors (bool, 可选, 默认为 None) — 是否使用 safetensors 检查点。默认为 None。如果未指定且未安装 safetensors，则将其设置为 False。
weights_only (bool, 可选, 默认为 True) — 指示解封装器是否应仅限于加载张量、基本类型、字典和通过 torch.serialization.add_safe_globals() 添加的任何类型。设置为 False 时，我们可以加载包装器张量子类权重。
key_mapping (dict[str, str], 可选) — 如果使用与 Transformers 架构兼容但未相应转换的 Hub 上的模型，则为权重名称的潜在映射。
kwargs (剩余的关键字参数字典，可选) — 可用于更新配置对象（加载后）并初始化模型（例如，output_attentions=True）。其行为取决于是否提供了 config 或自动加载：
- 如果提供了 config，**kwargs 将直接传递给底层模型的 __init__ 方法（我们假设所有相关的配置更新都已完成）
- 如果未提供配置，kwargs 将首先传递给配置类初始化函数（from_pretrained()）。kwargs 中与配置属性对应的每个键都将用于使用提供的 kwargs 值覆盖该属性。不对应任何配置属性的剩余键将传递给底层模型的 __init__ 函数。

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

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

警告Weights from XXX not initialized from pretrained model表示 XXX 的权重未随模型的其余部分预训练。您需要使用下游微调任务来训练这些权重。

警告Weights from XXX not used in YYY表示层 XXX 未被 YYY 使用，因此这些权重被丢弃。

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

示例

>>> 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)

get_compiled_call

( compile_config: typing.Optional[transformers.generation.configuration_utils.CompileConfig] )

返回 self.__call__ 的 torch.compile 版本。这对于在推理期间动态选择非编译/编译的 forward 非常有用，尤其是在预填充（我们不想使用编译版本以避免使用新形状重新计算图）和迭代解码（我们希望通过静态形状获得编译版本的加速）之间切换时。

get_input_embeddings

( ) → nn.Module

nn.Module

将词汇映射到隐藏状态的 torch 模块。

返回模型的输入嵌入。

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

将隐藏状态映射到词汇的 torch 模块。

返回模型的输出嵌入。

get_parameter_or_buffer

( target: str )

如果存在，则返回由 target 给定的参数或缓冲区，否则抛出错误。这在一个便捷的函数中结合了 get_parameter() 和 get_buffer()。如果目标是 _extra_state 属性，它将返回模块提供的额外状态。请注意，它仅在 target 是模型的叶节点时才有效。

gradient_checkpointing_disable

( )

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

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

gradient_checkpointing_enable

( gradient_checkpointing_kwargs = None )

参数

gradient_checkpointing_kwargs (字典, 可选) — 传递给 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 中实现任何初始化逻辑。

initialize_weights

( )

这相当于调用 self.apply(self._initialize_weights)，但正确处理了复合模型。此函数动态地将正确的 init_weights 函数分派给模块，因为我们在模块图沿递归进行。它可以处理任意数量的子模型。如果没有它，每个复合模型都必须在最外层的 _init_weights 中显式地对所有子模型进行第二次递归，这极易出错且效率低下。

另请注意，torch.no_grad() 装饰器也非常重要，因为我们的大多数 _init_weights 不使用 torch.nn.init 函数（默认情况下都是 no_grad），而只是执行就地操作，例如 `module.weight.data.zero_()`。

post_init

( )

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

prune_heads

( heads_to_prune: dict )

参数

heads_to_prune (dict[int, list[int]]) — 字典，其中键为选定的层索引 (int)，关联值为在该层中要修剪的注意力头列表 (list of 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") — 要注册此新模型的自动类。

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

resize_token_embeddings

( new_num_tokens: typing.Optional[int] = None pad_to_multiple_of: typing.Optional[int] = None mean_resizing: bool = True ) → torch.nn.Embedding

参数

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

这对于在计算能力 >= 7.5 (Volta) 的 NVIDIA 硬件上，或在序列长度为 128 倍数的 TPU 上，启用 Tensor Cores 的使用特别有用。有关此内容的更多详细信息，或有关选择正确大小调整值的帮助，请参阅此指南：https://docs.nvda.net.cn/deeplearning/performance/dl-performance-matrix-multiplication/index.html#requirements-tc
mean_resizing (bool) — 是否从具有旧嵌入均值和协方差的多元正态分布初始化新增嵌入，或者是否使用均值为零且标准差等于 config.initializer_range 的正态分布初始化它们。

当增加因果语言模型的嵌入大小时，将 mean_resizing 设置为 True 非常有用，因为新增嵌入不会影响生成的 token 的概率，因为用旧嵌入的均值初始化新嵌入将减少新增嵌入前后下一个 token 概率之间的 kl-散度。有关更多信息，请参阅此文章：https://nlp.stanford.edu/~johnhew/vocab-expansion.html

torch.nn.Embedding

指向模型输入 token 嵌入模块的指针。

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

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

reverse_bettertransformer

( ) → PreTrainedModel

PreTrainedModel

转换回原始建模的模型。

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

save_pretrained

( save_directory: typing.Union[str, os.PathLike] is_main_process: bool = True state_dict: typing.Optional[dict] = None save_function: typing.Callable = <function save at 0x7f0107b99fc0> push_to_hub: bool = False max_shard_size: typing.Union[int, str] = '5GB' safe_serialization: bool = True variant: typing.Optional[str] = None token: typing.Union[str, bool, NoneType] = None save_peft_format: bool = True **kwargs )

参数

save_directory (str 或 os.PathLike) — 保存到的目录。如果不存在，将创建。
is_main_process (bool, 可选, 默认为 True) — 调用此过程的进程是否为主进程。在分布式训练（如 TPUs）中非常有用，需要在所有进程上调用此函数。在这种情况下，仅在主进程上设置 is_main_process=True 以避免竞争条件。
state_dict (torch.Tensor 的嵌套字典) — 要保存的模型的状态字典。默认为 self.state_dict()，但可用于仅保存模型的一部分，或者在恢复模型的状态字典时需要特殊预防措施（例如在使用模型并行时）。
save_function (Callable) — 用于保存状态字典的函数。在分布式训练（如 TPUs）中非常有用，当需要用另一种方法替换 torch.save 时。
push_to_hub (bool, 可选, 默认为 False) — 是否在保存模型后将其推送到 Hugging Face 模型 hub。您可以使用 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 bearer 授权的 token。如果为 True 或未指定，将使用运行 huggingface-cli login 时生成的 token（存储在 ~/.huggingface 中）。
save_peft_format (bool, 可选, 默认为 True) — 为了与 PEFT 库向后兼容，如果适配器权重附加到模型，则适配器状态字典的所有键都需要以 base_model.model 为前缀。高级用户可以通过将 save_peft_format 设置为 False 来禁用此行为。
kwargs (dict[str, Any], optional) — 传递给 push_to_hub() 方法的附加关键字参数。

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

set_input_embeddings

( value: Module )

参数

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

设置模型的输入嵌入。

tie_weights

( )

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

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

to_bettertransformer

( ) → PreTrainedModel

PreTrainedModel

转换为 BetterTransformer 的模型。

通过 Optimum 库将模型转换为使用 PyTorch 的原生注意力实现。仅支持所有 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

class 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

总的 token 数量。

一个辅助函数，用于从模型输入中估算总的 token 数量。

floating_point_ops

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

参数

batch_size (int) — 前向传播的批次大小。
sequence_length (int) — 批次中每行的 token 数量。
exclude_embeddings (bool, optional, defaults to True) — 是否计算嵌入和 softmax 操作。

int

浮点运算次数。

获取此 transformer 模型的正向和反向传播的（可选地，非嵌入）浮点运算次数。默认近似忽略了对 token 数量的二次依赖（在 `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 表示要关注的 token，0 表示要忽略的 token。
input_shape (tuple[int]) — 模型输入的形状。

制作可广播的注意力掩码和因果掩码，以便忽略未来和被掩码的 token。

get_head_mask

( head_mask: typing.Optional[torch.Tensor] 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

class 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, 可选) — 是否将仓库设为私有。如果为 `None`（默认），仓库将是公共的，除非组织的默认设置为私有。如果仓库已存在，此值将被忽略。
token (bool 或 str, 可选) — 用作远程文件 HTTP 承载授权的令牌。如果为 `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

布尔值

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

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

compile

( 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: Optional[bool] = None **kwargs )

参数

pretrained_model_name_or_path (str, optional) — 可以是以下任意一种：
- 一个字符串，是托管在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，因为我们在huggingface.co上使用基于git的系统存储模型和其他工件，所以revision可以是git允许的任何标识符。

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

警告Weights from XXX not initialized from pretrained model表示 XXX 的权重未随模型的其余部分预训练。您需要使用下游微调任务来训练这些权重。

警告Weights from XXX not used in YYY表示层 XXX 未被 YYY 使用，因此这些权重被丢弃。

示例

>>> 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)

get_bias

( ) → tf.Variable

tf.Variable

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

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

get_head_mask

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

参数

head_mask (tf.Tensor，形状为[num_heads]或[num_hidden_layers x num_heads]，可选) — 指示我们是否应保留头部的掩码（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

字符串

偏置的_前缀名称。

获取偏置从模型名称到父层的连接_前缀名称

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, 可选) — 如果批次大小不能均匀地划分数据集长度，是否丢弃最后一个批次。默认为与shuffle相同的设置。
prefetch (bool, 默认为True) — 是否在tf.data管道的末尾添加预取。这几乎总是对性能有益的，但在特殊情况下可以禁用。

数据集

一个准备好传递给Keras API的tf.data.Dataset。

将HuggingFace Dataset封装为具有整理和批处理功能的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") — 用于注册此新模型的自动类。

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

resize_token_embeddings

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

参数

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

tf.Variable 或 keras.layers.Embedding

指向模型输入令牌的指针。

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

如果模型类具有 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 保存时。— 输入 (dict[str, tf.Tensor]): 保存模型输入，以张量字典形式。

serving_output

( 输出 )

准备保存的模型输出。如果需要进行特定的服务修改，可以覆盖此方法。

set_bias

( 值 )

参数

值 (dict[tf.Variable]) — 所有附加到 LM head 的新偏置。

设置 LM head 中的所有偏置。

set_input_embeddings

( 值 )

参数

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

设置模型的输入嵌入。

set_output_embeddings

( 值 )

参数

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

设置模型的输出嵌入。

test_step

( 数据 )

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

train_step

( 数据 )

TFModelUtilsMixin

类 transformers.modeling_tf_utils.TFModelUtilsMixin

( )

keras.Model 的一些实用工具，用作混合。

num_parameters

( 仅可训练: bool = False ) → 整数

参数

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

int

参数的数量。

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

FlaxPreTrainedModel

类 transformers.FlaxPreTrainedModel

( 配置: PretrainedConfig 模块: Module 输入形状: tuple = (1, 1) 种子: int = 0 数据类型: 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 (bool, 可选) — 是否使用临时目录存储保存后要推送到 Hub 的文件。如果不存在名为 repo_id 的目录，则默认为 True，否则为 False。
commit_message (str, 可选) — 推送时的提交消息。默认为 "Upload model"。
private (bool, 可选) — 是否将仓库设为私有。如果为 None（默认），仓库将是公开的，除非组织的默认设置为私有。如果仓库已存在，此值将被忽略。
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) — 是否将模型权重转换为安全张量格式以实现更安全的序列化。
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

( 预训练模型名称或路径: typing.Union[str, os.PathLike] 数据类型: dtype = <class 'jax.numpy.float32'> *模型参数配置: typing.Union[transformers.configuration_utils.PretrainedConfig, str, os.PathLike, NoneType] = None 缓存目录: typing.Union[str, os.PathLike, NoneType] = None 忽略不匹配大小: bool = False 强制下载: bool = False 仅本地文件: bool = False 令牌: typing.Union[bool, str, NoneType] = None 修订版: 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 执行。

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

如果您希望更改模型参数的数据类型，请参阅 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) — 如果检查点中的某些权重与模型权重大小不一致（例如，您正在实例化一个具有 10 个标签的模型，而检查点具有 3 个标签），是否引发错误。
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 模型。

警告Weights from XXX not initialized from pretrained model表示 XXX 的权重未随模型的其余部分预训练。您需要使用下游微调任务来训练这些权重。

警告Weights from XXX not used in YYY表示层 XXX 未被 YYY 使用，因此这些权重被丢弃。

示例

>>> 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)

load_flax_sharded_weights

( 分片文件 ) → 字典

参数

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

字典

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

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

此加载操作高效执行：每个检查点分片逐一加载到 RAM 中，并在加载到模型后删除。

register_for_auto_class

( 自动类 = 'FlaxAutoModel' )

参数

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

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

save_pretrained

( 保存目录: typing.Union[str, os.PathLike] 参数 = None 推送到集线器 = False 最大分片大小 = '10GB' 令牌: typing.Union[bool, str, NoneType] = None 安全序列化: 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 承载授权令牌。如果为 True 或未指定，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。
kwargs (dict[str, Any], 可选) — 传递给 push_to_hub() 方法的其他关键字参数。
safe_serialization (bool, 可选, 默认为 False) — 是否使用 safetensors 或 msgpack 保存模型。

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

to_bf16

( params: typing.Union[dict, flax.core.frozen_dict.FrozenDict] mask: typing.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: typing.Union[dict, flax.core.frozen_dict.FrozenDict] mask: typing.Any = None )

参数

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

将浮点 params 转换为 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: typing.Union[dict, flax.core.frozen_dict.FrozenDict] mask: typing.Any = None )

参数

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

将浮点 params 转换为 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

class transformers.utils.PushToHubMixin

( )

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

push_to_hub

参数

repo_id (str) — 您要将 {object} 推送到的存储库的名称。当推送到给定组织时，它应包含您的组织名称。
use_temp_dir (bool, 可选) — 是否使用临时目录存储在推送到 Hub 之前保存的文件。如果没有名为 repo_id 的目录，则默认为 True，否则为 False。
commit_message (str, 可选) — 推送时的提交消息。默认为 "Upload {object}"。
private (bool, 可选) — 是否将仓库设为私有。如果为 None（默认），除非组织默认为私有，否则仓库将是公共的。如果仓库已存在，此值将被忽略。
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 的标签列表。

将 {object_files} 上传到 🤗 模型 Hub。

示例

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