Transformers 4.37 中文文档（十四）
Transformers 4.37 中文文档（十四）
ApacheCN_飞龙
发布于 2024-06-26 15:08:09
发布于 2024-06-26 15:08:09
骨干
原文链接：
huggingface.co/docs/transformers/v4.37.2/en/main_classes/backbones
骨干是用于计算机视觉任务的特征提取模型。可以通过两种方式之一将模型用作骨干：
- 使用预训练模型初始化
AutoBackbone类， - 初始化支持的骨干配置并将其传递给模型架构。
使用 AutoBackbone
您可以使用AutoBackbone类初始化一个模型作为骨干，并获取任何阶段的特征图。您可以定义out_indices来指示您想要从哪些层获取特征图。如果您知道层的名称，也可以使用out_features。您可以互换使用它们。如果同时使用out_indices和out_features，请确保它们是一致的。不传递任何特征图参数将使骨干产生最后一层的特征图。为了可视化各个阶段的外观，让我们以 Swin 模型为例。每个阶段负责特征提取，输出特征图。
第一阶段的特征图如下所示。
让我们通过一个示例来看看。请注意，out_indices=(0,)会导致产生模型的 stem。Stem 指的是第一个特征提取阶段之前的阶段。在上图中，它指的是 patch 分区。我们希望从 stem、第一阶段和第二阶段获取特征图。
>>> from transformers import AutoImageProcessor, AutoBackbone
>>> import torch
>>> from PIL import Image
>>> import requests
>>> processor = AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224")
>>> model = AutoBackbone.from_pretrained("microsoft/swin-tiny-patch4-window7-224", out_indices=(0,1,2))
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> feature_maps = outputs.feature_mapsfeature_maps对象现在有三个特征图，每个都可以像下面这样访问。假设我们想要获取 stem 的特征图。
>>> list(feature_maps[0].shape)
[1, 96, 56, 56]我们可以像下面这样获取第一阶段和第二阶段的特征图。
>>> list(feature_maps[1].shape)
[1, 96, 56, 56]
>>> list(feature_maps[2].shape)
[1, 192, 28, 28]初始化骨干配置
在计算机视觉中，模型由骨干、neck 和头部组成。骨干提取特征，neck 转换骨干的输出，头部用于主要任务（例如目标检测）。您可以通过将模型配置传递给backbone_config来使用模型骨干初始化 neck 和头部。例如，您可以看到如何使用 ResNet 骨干初始化带有实例分割头部的 MaskFormer 模型。
from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, ResNetConfig
backbone_config = ResNetConfig.from_pretrained("microsoft/resnet-50")
config = MaskFormerConfig(backbone_config=backbone_config)
model = MaskFormerForInstanceSegmentation(config)您还可以使用随机权重初始化骨干，以初始化模型的 neck。
backbone_config = ResNetConfig()
config = MaskFormerConfig(backbone_config=backbone_config)
model = MaskFormerForInstanceSegmentation(config)通过TimmBackbone和TimmBackboneConfig，transformers 还支持timm模型。
from transformers import TimmBackboneConfig, TimmBackbone
backbone_config = TimmBackboneConfig("resnet50")
model = TimmBackbone(config=backbone_config)回调函数
原始文本：
huggingface.co/docs/transformers/v4.37.2/en/main_classes/callback
回调函数是可以自定义 PyTorch Trainer 训练循环行为的对象（此功能尚未在 TensorFlow 中实现），可以检查训练循环状态（用于进度报告、在 TensorBoard 或其他 ML 平台上记录…）并做出决策（如提前停止）。
回调函数是“只读”代码片段，除了它们返回的 TrainerControl 对象外，它们不能更改训练循环中的任何内容。对于需要更改训练循环的自定义内容，您应该子类化 Trainer 并覆盖您需要的方法（请参阅 trainer 以获取示例）。
默认情况下，TrainingArguments.report_to设置为"all"，因此 Trainer 将使用以下回调函数。
- DefaultFlowCallback 处理日志记录、保存和评估的默认行为。
- 使用 PrinterCallback 或 ProgressCallback 显示进度并打印日志（如果通过 TrainingArguments 停用 tqdm，则使用第一个，否则使用第二个）。
- 如果 tensorboard 可访问（通过 PyTorch >= 1.4 或 tensorboardX），则使用 TensorBoardCallback。
- 如果安装了wandb，则使用 WandbCallback。
- 如果安装了comet_ml，则使用 CometCallback。
- 如果安装了mlflow，则使用 MLflowCallback。
- 如果安装了neptune，则使用 NeptuneCallback。
- 如果安装了azureml-sdk，则使用 AzureMLCallback。
- 如果安装了codecarbon，则使用 CodeCarbonCallback。
- 如果安装了clearml，则使用 ClearMLCallback。
- 如果安装了dagshub，则使用 DagsHubCallback。
- 如果安装了flyte，则使用 FlyteCallback。
- 如果安装了dvclive，则使用 DVCLiveCallback。
如果安装了某个软件包，但您不希望使用相应的集成，可以将TrainingArguments.report_to更改为您想要使用的集成列表（例如["azure_ml", "wandb"]）。
实现回调的主要类是 TrainerCallback。它获取用于实例化 Trainer 的 TrainingArguments，可以通过 TrainerState 访问该 Trainer 的内部状态，并可以通过 TrainerControl 对训练循环采取一些操作。
可用的回调
以下是库中可用的 TrainerCallback 列表：
class transformers.integrations.CometCallback
( )一个将日志发送到Comet ML的 TrainerCallback。
setup
( args state model )设置可选的 Comet.ml 集成。
环境：
-
COMET_MODE(str, 可选，默认为ONLINE): 是否创建在线、离线实验或禁用 Comet 日志记录。可以是OFFLINE、ONLINE或DISABLED。 -
COMET_PROJECT_NAME(str, 可选): 用于实验的 Comet 项目名称。 -
COMET_OFFLINE_DIRECTORY(str, 可选): 在COMET_MODE为OFFLINE时用于保存离线实验的文件夹。 -
COMET_LOG_ASSETS(str, 可选，默认为TRUE): 是否将训练资产（tf 事件日志、检查点等）记录到 Comet。可以是TRUE或FALSE。
有关环境中可配置项目的详细信息，请参阅此处。
class transformers.DefaultFlowCallback
( )处理训练循环的默认流程，包括日志、评估和检查点的 TrainerCallback。
class transformers.PrinterCallback
( )一个简单的 TrainerCallback，只打印日志。
class transformers.ProgressCallback
( )一个显示训练或评估进度的 TrainerCallback。
class transformers.EarlyStoppingCallback
( early_stopping_patience: int = 1 early_stopping_threshold: Optional = 0.0 )参数
-
early_stopping_patience(int) — 与metric_for_best_model一起使用，当指定的指标在early_stopping_patience次评估调用中恶化时停止训练。 -
early_stopping_threshold(float,可选) — 与 TrainingArguments 的metric_for_best_model和early_stopping_patience一起使用，表示指定指标必须改善多少才能满足提前停止条件。
一个处理提前停止的 TrainerCallback。
此回调取决于 TrainingArguments 参数load_best_model_at_end功能，以在 TrainerState 中设置 best_metric。请注意，如果 TrainingArguments 参数save_steps与eval_steps不同，则直到下一个保存步骤才会发生早停。
class transformers.integrations.TensorBoardCallback
( tb_writer = None )参数
tb_writer（SummaryWriter，可选）—要使用的写入器。如果未设置，将实例化一个。
一个 TrainerCallback，将日志发送到TensorBoard。
class transformers.integrations.WandbCallback
( )一个 TrainerCallback，将指标、媒体、模型检查点记录到Weights and Biases。
setup
( args state model **kwargs )设置可选的 Weights & Biases（wandb）集成。
如果需要，可以子类化并重写此方法以自定义设置。在这里找到更多信息。您还可以重写以下环境变量：
环境：
-
WANDB_LOG_MODEL（str，可选，默认为"false"）：是否在训练期间记录模型和检查点。可以是"end"，"checkpoint"或"false"。如果设置为"end"，模型将在训练结束时上传。如果设置为"checkpoint"，将在每次args.save_steps保存时上传检查点。如果设置为"false"，模型将不会上传。与load_best_model_at_end()一起使用以上传最佳模型。 在 5.0 中已弃用 在🤗 Transformers 的第 5 版中，将废弃将WANDB_LOG_MODEL设置为bool。 -
WANDB_WATCH（str，可选，默认为"false"）：可以是"gradients"，"all"，"parameters"或"false"。设置为"all"以记录梯度和参数。 -
WANDB_PROJECT（str，可选，默认为"huggingface"）：将其设置为自定义字符串以将结果存储在不同的项目中。 -
WANDB_DISABLED（bool，可选，默认为False）：是否完全禁用 wandb。设置WANDB_DISABLED=true以禁用。
class transformers.integrations.MLflowCallback
( )一个 TrainerCallback，将日志发送到MLflow。可以通过设置环境变量DISABLE_MLFLOW_INTEGRATION = TRUE来禁用。
setup
( args state model )设置可选的 MLflow 集成。
环境：
-
HF_MLFLOW_LOG_ARTIFACTS（str，可选）：是否使用 MLflow 的.log_artifact()功能来记录工件。只有在将日志记录到远程服务器（例如 s3 或 GCS）时才有意义。如果设置为True或1，将在每次在 TrainingArguments 的output_dir中保存时将每个保存的检查点复制到本地或远程工件存储。在没有远程存储的情况下使用它将只是将文件复制到您的工件位置。 -
MLFLOW_EXPERIMENT_NAME(str, 可选, 默认为None)：是否使用 MLflow 实验名称来启动运行。默认为None，将指向 MLflow 中的Default实验。否则，它是要激活的实验的区分大小写名称。如果不存在具有此名称的实验，则将创建一个具有此名称的新实验。 -
MLFLOW_TAGS(str, 可选)：要添加到 MLflow 运行中的标签的键/值对的字符串转储。示例：os.environ['MLFLOW_TAGS']='{"release.candidate": "RC1", "release.version": "2.2.0"}'。 -
MLFLOW_NESTED_RUN(str, 可选)：是否使用 MLflow 嵌套运行。如果设置为True或1，将在当前运行内创建一个嵌套运行。 -
MLFLOW_RUN_ID(str, 可选)：允许重新附加到现有运行，这在从检查点恢复训练时可能很有用。当设置了MLFLOW_RUN_ID环境变量时，start_run尝试恢复具有指定运行 ID 的运行，其他参数将被忽略。 -
MLFLOW_FLATTEN_PARAMS(str, 可选, 默认为False)：是否在记录之前展平参数字典。
class transformers.integrations.AzureMLCallback
( azureml_run = None )一个 TrainerCallback，将日志发送到AzureML。
class transformers.integrations.CodeCarbonCallback
( )一个 TrainerCallback，用于跟踪训练的 CO2 排放量。
class transformers.integrations.NeptuneCallback
( api_token: Optional = None project: Optional = None name: Optional = None base_namespace: str = 'finetuning' run = None log_parameters: bool = True log_checkpoints: Optional = None **neptune_run_kwargs )参数
-
api_token(str, 可选) — 在注册时获得的 Neptune API 令牌。如果已将令牌保存到NEPTUNE_API_TOKEN环境变量中，可以省略此参数（强烈建议）。在文档中查看完整的设置说明。 -
project(str, 可选) — Neptune 项目的名称，格式为“workspace-name/project-name”。您可以在 Neptune 中的项目设置 -> 属性中找到并复制名称。如果为 None（默认），则使用NEPTUNE_PROJECT环境变量的值。 -
name(str, 可选) — 运行的自定义名称。 -
base_namespace(str, 可选, 默认为“finetuning”) — 在 Neptune 运行中，将包含回调记录的所有元数据的根命名空间。 -
log_parameters(bool, 可选, 默认为True) — 如果为 True，则记录 Trainer 提供的所有参数和模型参数。 -
log_checkpoints(str, 可选) — 如果为“same”，则在 Trainer 保存检查点时上传检查点。如果为“last”，则仅上传最近保存的检查点。如果为“best”，则上传最佳检查点（在 Trainer 保存的检查点中选择）。如果为None，则不上传检查点。 -
run(Run, 可选) — 如果要继续记录到现有运行中，请传递一个 Neptune 运行对象。在文档中了解更多关于恢复运行的信息。 - *
*neptune_run_kwargs(可选) — 传递给neptune.init_run()函数的其他关键字参数，当创建新运行时。
将日志发送到Neptune的 TrainerCallback。
有关说明和示例，请参阅 Neptune 文档中的Transformers 集成指南。
class transformers.integrations.ClearMLCallback
( )一个将日志发送到ClearML的 TrainerCallback。
环境：
-
CLEARML_PROJECT(str, 可选, 默认为HuggingFace Transformers): ClearML 项目名称。 -
CLEARML_TASK(str, 可选, 默认为Trainer): ClearML 任务名称。 -
CLEARML_LOG_MODEL(bool, 可选, 默认为False): 是否在训练期间将模型记录为工件。
class transformers.integrations.DagsHubCallback
( )一个将日志记录到DagsHub的 TrainerCallback。扩展MLflowCallback
setup
( *args **kwargs )设置 DagsHub 的日志记录集成。
环境：
HF_DAGSHUB_LOG_ARTIFACTS(str, 可选): 是否保存实验的数据和模型工件。默认为False。
class transformers.integrations.FlyteCallback
( save_log_history: bool = True sync_checkpoints: bool = True )参数
-
save_log_history(bool, 可选, 默认为True) — 当设置为 True 时，训练日志将保存为 Flyte Deck。 -
sync_checkpoints(bool, 可选, 默认为True) — 当设置为 True 时，检查点将与 Flyte 同步，并可用于在中断的情况下恢复训练。
一个将日志发送到Flyte的 TrainerCallback。注意：此回调仅在 Flyte 任务内起作用。
示例：
# Note: This example skips over some setup steps for brevity.
from flytekit import current_context, task
@task
def train_hf_transformer():
cp = current_context().checkpoint
trainer = Trainer(..., callbacks=[FlyteCallback()])
output = trainer.train(resume_from_checkpoint=cp.restore())class transformers.integrations.DVCLiveCallback
( live: Optional = None log_model: Union = None **kwargs )参数
-
live(dvclive.Live, 可选, 默认为None) — 可选的 Live 实例。如果为 None，则将使用**kwargs 创建一个新实例。 -
log_model(Union[Literal["all"], bool], 可选, 默认为None) — 是否使用dvclive.Live.log_artifact()来记录 Trainer 创建的检查点。如果设置为True，则在训练结束时记录最终检查点。如果设置为"all"，则在每个检查点处记录整个 TrainingArguments 的output_dir。
一个将日志发送到DVCLive的 TrainerCallback。
在setup中使用下面的环境变量来配置集成。要在这些环境变量之外自定义此回调，请参阅此处。
setup
( args state model )设置可选的 DVCLive 集成。要在环境变量之外自定义此回调，请参阅此处。
环境：
HF_DVCLIVE_LOG_MODEL(str, 可选): 是否使用dvclive.Live.log_artifact()来记录 Trainer 创建的检查点。如果设置为True或1，则在训练结束时记录最终检查点。如果设置为all，则在每个检查点处记录整个 TrainingArguments 的output_dir。
TrainerCallback
class transformers.TrainerCallback
( )参数
-
args(TrainingArguments) — 用于实例化 Trainer 的训练参数。 -
state(TrainerState) — Trainer 的当前状态。 -
control(TrainerControl) — 返回给 Trainer 并可用于做出一些决策的对象。 -
model(PreTrainedModel 或torch.nn.Module) — 正在训练的模型。 -
tokenizer(PreTrainedTokenizer) — 用于编码数据的分词器。 -
optimizer(torch.optim.Optimizer) — 用于训练步骤的优化器。 -
lr_scheduler(torch.optim.lr_scheduler.LambdaLR) — 用于设置学习率的调度器。 -
train_dataloader(torch.utils.data.DataLoader, optional) — 用于训练的当前数据加载器。 -
eval_dataloader(torch.utils.data.DataLoader, optional) — 用于训练的当前数据加载器。 -
metrics(Dict[str, float]) — 上次评估阶段计算的指标。 这些只能在事件on_evaluate中访问。 -
logs(Dict[str, float]) — 要记录的值。 这些只能在事件on_log中访问。
一个用于在某些事件中检查训练循环状态并做出一些决策的对象类。在每个事件中，以下参数都是可用的：
control对象是唯一可以被回调函数更改的对象，如果更改了control的事件应该返回修改后的版本。
参数args、state和control对于所有事件都是位置参数，其他参数都被分组在kwargs中。您可以在事件的签名中解包您需要的参数。例如，查看简单的 PrinterCallback 的代码。
示例：
class PrinterCallback(TrainerCallback):
def on_log(self, args, state, control, logs=None, **kwargs):
_ = logs.pop("total_flos", None)
if state.is_local_process_zero:
print(logs)on_epoch_begin
( args: TrainingArguments state: TrainerState control: TrainerControl **kwargs )在一个 epoch 开始时调用的事件。
on_epoch_end
( args: TrainingArguments state: TrainerState control: TrainerControl **kwargs )在一个 epoch 结束时调用的事件。
on_evaluate
( args: TrainingArguments state: TrainerState control: TrainerControl **kwargs )在评估阶段后调用的事件。
on_init_end
( args: TrainingArguments state: TrainerState control: TrainerControl **kwargs )在 Trainer 初始化结束时调用的事件。
on_log
( args: TrainingArguments state: TrainerState control: TrainerControl **kwargs )在记录最后日志后调用的事件。
on_predict
( args: TrainingArguments state: TrainerState control: TrainerControl metrics **kwargs )在成功预测后调用的事件。
on_prediction_step
( args: TrainingArguments state: TrainerState control: TrainerControl **kwargs )在预测步骤后调用的事件。
on_save
( args: TrainingArguments state: TrainerState control: TrainerControl **kwargs )在保存检查点后调用的事件。
on_step_begin
( args: TrainingArguments state: TrainerState control: TrainerControl **kwargs )在训练步骤开始时调用的事件。如果使用梯度累积，一个训练步骤可能需要多个输入。
on_step_end
( args: TrainingArguments state: TrainerState control: TrainerControl **kwargs )在训练步骤结束时调用的事件。如果使用梯度累积，一个训练步骤可能需要多个输入。
on_substep_end
( args: TrainingArguments state: TrainerState control: TrainerControl **kwargs )在梯度累积期间子步骤结束时调用的事件。
on_train_begin
( args: TrainingArguments state: TrainerState control: TrainerControl **kwargs )在训练开始时调用的事件。
on_train_end
( args: TrainingArguments state: TrainerState control: TrainerControl **kwargs )在训练结束时调用的事件。
这是一个如何在 PyTorch Trainer 中注册自定义回调的示例：
class MyCallback(TrainerCallback):
"A callback that prints a message at the beginning of training"
def on_train_begin(self, args, state, control, **kwargs):
print("Starting training")
trainer = Trainer(
model,
args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
callbacks=[MyCallback], # We can either pass the callback class this way or an instance of it (MyCallback())
)另一种注册回调的方法是调用trainer.add_callback()如下：
trainer = Trainer(...)
trainer.add_callback(MyCallback)
# Alternatively, we can pass an instance of the callback class
trainer.add_callback(MyCallback())TrainerState
class transformers.TrainerState
( epoch: Optional = None global_step: int = 0 max_steps: int = 0 logging_steps: int = 500 eval_steps: int = 500 save_steps: int = 500 train_batch_size: int = None num_train_epochs: int = 0 num_input_tokens_seen: int = 0 total_flos: float = 0 log_history: List = None best_metric: Optional = None best_model_checkpoint: Optional = None is_local_process_zero: bool = True is_world_process_zero: bool = True is_hyper_param_search: bool = False trial_name: str = None trial_params: Dict = None )参数
-
epoch(float, 可选) — 仅在训练期间设置，表示训练所处的时代（小数部分表示当前时代完成的百分比）。 -
global_step(int, 可选, 默认为 0) — 在训练过程中，表示已完成的更新步骤数量。 -
max_steps(int, 可选, 默认为 0) — 当前训练要执行的更新步骤数量。 -
logging_steps(int, 可选, 默认为 500) — 每 X 个更新步骤记录一次日志 -
eval_steps(int, 可选) — 每 X 步运行一次评估。 -
save_steps(int, 可选, 默认为 500) — 每 X 个更新步骤保存一次检查点。 -
train_batch_size(int, 可选) — 训练数据加载器的批量大小。仅在使用auto_find_batch_size时需要。 -
num_input_tokens_seen(int, 可选, 默认为 0) — 训练期间看到的标记数量（输入标记数量，而不是预测标记数量）。 -
total_flos(float, 可选, 默认为 0) — 自训练开始以来模型执行的浮点操作总数（存储为浮点数以避免溢出）。 -
log_history(List[Dict[str, float]], 可选) — 自训练开始以来完成的日志列表。 -
best_metric(float, 可选) — 跟踪最佳模型时，迄今为止遇到的最佳指标的值。 -
best_model_checkpoint(str, 可选) — 跟踪最佳模型时，迄今为止遇到的最佳模型的检查点名称的值。 -
is_local_process_zero(bool, 可选, 默认为True) — 是否这个进程是本地（例如，在多台机器上以分布式方式训练时，是一台机器上的主进程）。 -
is_world_process_zero(bool, 可选, 默认为True) — 是否这个进程是全局主进程（在多台机器上以分布式方式训练时，只有一个进程会是True）。 -
is_hyper_param_search(bool, 可选, 默认为False) — 是否正在使用 Trainer.hyperparameter_search 进行超参数搜索。这将影响数据在 TensorBoard 中记录的方式。
一个包含将在检查点时保存的 Trainer 内部状态的类，并传递给 TrainerCallback。
在这个类中，一个步骤被理解为一个更新步骤。当使用梯度累积时，一个更新步骤可能需要多次前向和后向传递：如果使用gradient_accumulation_steps=n，则一个更新步骤需要通过n批次。
load_from_json
( json_path: str )从json_path的内容创建一个实例。
save_to_json
( json_path: str )将此实例的内容以 JSON 格式保存在json_path中。
TrainerControl
class transformers.TrainerControl
( should_training_stop: bool = False should_epoch_stop: bool = False should_save: bool = False should_evaluate: bool = False should_log: bool = False )参数
-
should_training_stop（bool，可选，默认为False）—是否应中断训练。 如果为True，则此变量不会被设置回False。训练将直接停止。 -
should_epoch_stop（bool，可选，默认为False）—当前轮是否应中断。 如果为True，则此变量将在下一轮开始时设置回False。 -
should_save（bool，可选，默认为False）—模型是否应在此步骤保存。 如果为True，则此变量将在下一步开始时设置回False。 -
should_evaluate（bool，可选，默认为False）—模型是否应在此步骤进行评估。 如果为True，则此变量将在下一步开始时设置回False。 -
should_log（bool，可选，默认为False）—是否应在此步骤报告日志。 如果为True，则此变量将在下一步开始时设置回False。
处理 Trainer 控制流的类。此类由 TrainerCallback 使用，以在训练循环中激活一些开关。
配置
原始文本：
huggingface.co/docs/transformers/v4.37.2/en/main_classes/configuration
基类 PretrainedConfig 实现了从本地文件或目录加载/保存配置的常用方法，或者从库提供的预训练模型配置（从 HuggingFace 的 AWS S3 存储库下载）。
每个派生的配置类都实现了特定于模型的属性。所有配置类中共有的属性是：hidden_size、num_attention_heads 和 num_hidden_layers。文本模型进一步实现了：vocab_size。
PretrainedConfig
class transformers.PretrainedConfig
( **kwargs )参数
-
name_or_path(str, 可选, 默认为"") — 存储传递给 PreTrainedModel.from_pretrained() 或 TFPreTrainedModel.from_pretrained() 作为pretrained_model_name_or_path的字符串，如果配置是使用这种方法创建的。 -
output_hidden_states(bool, 可选, 默认为False) — 模型是否应返回所有隐藏状态。 -
output_attentions(bool, 可选, 默认为False) — 模型是否应返回所有注意力。 -
return_dict(bool, 可选, 默认为True) — 模型是否应返回一个 ModelOutput 而不是一个普通元组。 -
is_encoder_decoder(bool, 可选, 默认为False) — 模型是否用作编码器/解码器。 -
is_decoder(bool, 可选, 默认为False) — 模型是否用作解码器或不用（在这种情况下，它用作编码器）。 -
cross_attention_hidden_size**(bool, 可选) — 如果模型用作编码器-解码器设置中的解码器，并且交叉注意力隐藏维度与self.config.hidden_size不同，则为交叉注意力层的隐藏大小。 -
add_cross_attention(bool, 可选, 默认为False) — 是否应向模型添加交叉注意力层。请注意，此选项仅适用于可以在 EncoderDecoderModel 类中用作解码器模型的模型，其中包括AUTO_MODELS_FOR_CAUSAL_LM中的所有模型。 -
tie_encoder_decoder(bool, 可选, 默认为False) — 是否应将所有编码器权重绑定到它们对应的解码器权重。这要求编码器和解码器模型具有完全相同的参数名称。 -
prune_heads(Dict[int, List[int]], 可选, 默认为{}) — 模型的剪枝头部。键是所选层索引，相关值是要在该层中剪枝的头部列表。 例如{1: [0, 2], 2: [2, 3]}将在第 1 层剪枝头部 0 和 2，第 2 层剪枝头部 2 和 3。 -
chunk_size_feed_forward(int, 可选, 默认为0) — 残差注意力块中所有前馈层的块大小。块大小为0表示前馈层未分块。大小为 n 的块表示前馈层一次处理n个序列长度的嵌入。有关前馈分块的更多信息，请参见 前馈分块是如何工作的？。
用于序列生成的参数
-
max_length(int, 可选, 默认为 20) — 默认情况下在模型的generate方法中将使用的最大长度。 -
min_length(int, optional, 默认为 0) — 在模型的generate方法中默认使用的最小长度。 -
do_sample(bool, optional, 默认为False) — 在模型的generate方法中默认使用的标志。是否使用采样；否则使用贪婪解码。 -
early_stopping(bool, optional, 默认为False) — 在模型的generate方法中默认使用的标志。是否在每批至少完成num_beams个句子时停止束搜索。 -
num_beams(int, optional, 默认为 1) — 在模型的generate方法中默认使用的束搜索数量。1 表示不使用束搜索。 -
num_beam_groups(int, optional, 默认为 1) — 为了确保在模型的generate方法中默认使用的不同束组之间的多样性，将num_beams分成的组数。1 表示不使用组束搜索。 -
diversity_penalty(float, optional, 默认为 0.0) — 用于控制组束搜索多样性的值，将在模型的generate方法中默认使用。0 表示没有多样性惩罚。惩罚越高，输出越多样化。 -
temperature(float, optional, 默认为 1.0) — 用于调节下一个标记概率的值，将在模型的generate方法中默认使用。必须严格为正数。 -
top_k(int, optional, 默认为 50) — 在模型的generate方法中默认使用的保留最高概率词汇标记的数量，用于 top-k 过滤。 -
top_p(float, optional, 默认为 1) — 用于top_p的默认值，将在模型的generate方法中使用。如果设置为 float < 1，只保留概率加起来达到top_p或更高的最有可能的标记用于生成。 -
typical_p(float, optional, 默认为 1) — 本地典型性衡量了预测下一个目标标记的条件概率与预期的条件概率有多相似，给定已生成的部分文本。如果设置为 float < 1，将保留概率加起来达到typical_p或更高的最具本地典型性的标记集。有关更多详细信息，请参阅此论文。 -
repetition_penalty(float, optional, 默认为 1) — 用于重复惩罚的参数，将在模型的generate方法中默认使用。1.0 表示没有惩罚。 -
length_penalty(float, optional, 默认为 1) — 用于基于束的生成的长度的指数惩罚。它作为指数应用于序列长度，然后用于分割序列的分数。由于分数是序列的对数似然（即负数），length_penalty> 0.0 促进更长的序列，而length_penalty< 0.0 鼓励更短的序列。 -
no_repeat_ngram_size(int, optional, 默认为 0) — 用于no_repeat_ngram_size的默认值，将在模型的generate方法中使用。如果设置为 int > 0，该大小的所有 ngram 只能出现一次。 -
encoder_no_repeat_ngram_size(int, optional, 默认为 0) — 用于encoder_no_repeat_ngram_size的默认值，将在模型的generate方法中使用。如果设置为 int > 0，encoder_input_ids中出现的该大小的所有 ngram 不能出现在decoder_input_ids中。 -
bad_words_ids(List[int], optional) — 不允许生成的标记 id 列表，将在模型的generate方法中默认使用。为了获取不应出现在生成文本中的单词的标记，请使用tokenizer.encode(bad_word, add_prefix_space=True)。 -
num_return_sequences(int, optional, 默认为 1) — 每个批次中每个元素默认在模型的generate方法中使用的独立计算返回序列的数量。 -
output_scores(bool, optional, 默认为False) — 当用于生成时，模型是否应返回 logits。 -
return_dict_in_generate(bool, optional, 默认为False) — 模型在生成时是否应返回 ModelOutput 而不是torch.LongTensor。 -
forced_bos_token_id(int, optional) — 在decoder_start_token_id之后强制作为第一个生成的标记的 id。对于多语言模型（如 mBART）很有用，其中第一个生成的标记需要是目标语言标记。 -
forced_eos_token_id(int, optional) — 当达到max_length时，强制作为最后生成的标记的 id。 -
remove_invalid_values(bool, optional) — 是否删除模型可能产生的nan和inf输出，以防止生成方法崩溃。请注意，使用remove_invalid_values可能会减慢生成速度。
用于微调任务的参数
-
architectures(List[str], optional) — 可与模型预训练权重一起使用的模型架构。 -
finetuning_task(str, optional) — 用于微调模型的任务名称。在从原始（TensorFlow 或 PyTorch）检查点转换时可以使用。 -
id2label(Dict[int, str], optional) — 从索引（例如预测索引或目标索引）到标签的映射。 -
label2id(Dict[str, int], optional) — 从标签到模型索引的映射。 -
num_labels(int, optional) — 在模型中添加的最后一层中要使用的标签数，通常用于分类任务。 -
task_specific_params(Dict[str, Any], optional) — 存储当前任务的额外关键字参数。 -
problem_type(str, optional) —XxxForSequenceClassification模型的问题类型。可以是"regression"、"single_label_classification"或"multi_label_classification"中的一个。
与分词器相关的参数
-
tokenizer_class(str, optional) — 要使用的关联分词器类的名称（如果未设置，则默认使用与模型关联的分词器）。 -
prefix(str, optional) — 每个文本前调用模型之前应添加的特定提示。 -
bos_token_id(int, optional) — 流的开始标记的 id。 -
pad_token_id(int, optional) — 填充标记的 id。 -
eos_token_id(int, optional) — 流的结束标记的 id。 -
decoder_start_token_id(int, optional) — 如果编码器-解码器模型开始解码时使用与bos不同的标记，则该标记的 id。 -
sep_token_id(int, optional) — 分隔标记的 id。
PyTorch 特定参数
-
torchscript(bool, optional, 默认为False) — 模型是否应与 Torchscript 一起使用。 -
tie_word_embeddings(bool, optional, 默认为True) — 模型的输入和输出词嵌入是否应该绑定。请注意，这仅在模型具有输出词嵌入层时才相关。 -
torch_dtype(str, optional) — 权重的dtype。此属性可用于将模型初始化为非默认的dtype（通常为float32），从而允许进行最佳存储分配。例如，如果保存的模型是float16，理想情况下我们希望使用最少的内存来加载float16权重。由于配置对象以纯文本形式存储，因此此属性仅包含浮点类型字符串，不包含torch.前缀。例如，对于torch.float16，torch_dtype是"float16"字符串。 此属性当前在模型加载时未被使用，但在将来的版本中可能会更改。但我们可以通过使用 save_pretrained 保存 dtype 来为未来做好准备。 -
attn_implementation(str, optional) — 模型中要使用的注意力实现。可以是"eager"（注意力的手动实现），"sdpa"（使用torch.nn.functional.scaled_dot_product_attention的注意力），或"flash_attention_2"（使用 Dao-AILab/flash-attention 的注意力）。默认情况下，如果可用，torch>=2.1.1 会使用 SDPA。否则，默认为手动的"eager"实现。
TensorFlow 特定参数
-
use_bfloat16(bool, optional, 默认为False) — 模型是否应该使用 BFloat16 标量（仅由某些 TensorFlow 模型使用）。 -
tf_legacy_loss(bool, optional, 默认为False) — 模型是否应该使用传统的 TensorFlow 损失。传统损失具有可变的输出形状，可能不兼容 XLA。此选项用于向后兼容，将在 Transformers v5 中删除。
所有配置类的基类。处理一些所有模型配置共有的参数，以及用于加载/下载/保存配置的方法。
可以加载和保存配置文件到磁盘。加载配置文件并使用此文件初始化模型 不会 加载模型权重。它只影响模型的配置。
类属性（由派生类覆盖）：
-
model_type(str) — 模型类型的标识符，序列化到 JSON 文件中，并用于在 AutoConfig 中重新创建正确的对象。 -
is_composition(bool) — 配置类是否由多个子配置组成。在这种情况下，配置必须从两个或更多类型为 PretrainedConfig 的配置初始化，如：EncoderDecoderConfig 或 ~RagConfig。 -
keys_to_ignore_at_inference(List[str]) — 推理期间查看模型字典输出时默认要忽略的键列表。 -
attribute_map(Dict[str, str]) — 将模型特定属性名称映射到属性的标准化命名的字典。
所有子类中存在的公共属性：
-
vocab_size(int) — 词汇表中的标记数，也是嵌入矩阵的第一个维度（对于没有文本模态的模型，此属性可能缺失）。 -
hidden_size(int) — 模型的隐藏大小。 -
num_attention_heads(int) — 模型中多头注意力层中使用的注意力头数。 -
num_hidden_layers(int) — 模型中的块数。
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, optional) — 是否使用临时目录存储在推送到 Hub 之前保存的文件。如果没有名为repo_id的目录，则默认为True，否则为False。 -
commit_message(str, optional) — 推送时要提交的消息。默认为"Upload config"。 -
private(bool, optional) — 是否应该创建私有存储库。 -
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 上的标签列表。
将配置文件上传到🤗模型 Hub。
示例：
from transformers import AutoConfig
config = AutoConfig.from_pretrained("bert-base-cased")
# Push the config to your namespace with the name "my-finetuned-bert".
config.push_to_hub("my-finetuned-bert")
# Push the config to an organization with the name "my-finetuned-bert".
config.push_to_hub("huggingface/my-finetuned-bert")dict_torch_dtype_to_str
( d: Dict )检查传递的字典及其嵌套字典是否具有torch_dtype键，如果不是 None，则将 torch.dtype 转换为仅类型的字符串。例如，torch.float32被转换为*“float32”*字符串，然后可以存储在 json 格式中。
from_dict
( config_dict: Dict **kwargs ) → export const metadata = 'undefined';PretrainedConfig参数
-
config_dict(Dict[str, Any]) — 将用于实例化配置对象的字典。可以通过利用 get_config_dict()方法从预训练检查点中检索这样的字典。 -
kwargs(Dict[str, Any]) — 用于初始化配置对象的其他参数。
返回
PretrainedConfig
从这些参数实例化的配置对象。
从参数字典实例化一个 PretrainedConfig。
from_json_file
( json_file: Union ) → export const metadata = 'undefined';PretrainedConfig参数
json_file(str或os.PathLike) — 包含参数的 JSON 文件的路径。
返回
PretrainedConfig
从该 JSON 文件实例化的配置对象。
从参数文件的路径实例化一个 PretrainedConfig。
from_pretrained
( pretrained_model_name_or_path: Union cache_dir: Union = None force_download: bool = False local_files_only: bool = False token: Union = None revision: str = 'main' **kwargs ) → export const metadata = 'undefined';PretrainedConfig参数
-
pretrained_model_name_or_path(str或os.PathLike) — 这可以是：- 一个字符串，托管在 huggingface.co 模型存储库中的预训练模型配置的模型 ID。有效的模型 ID 可以位于根级别，如
bert-base-uncased，或者在用户或组织名称下命名空间化，如dbmdz/bert-base-german-cased。 - 一个目录的路径，其中包含使用 save_pretrained()方法保存的配置文件，例如，
./my_model_directory/。 - 一个保存的配置 JSON 文件的路径或 URL，例如，
./my_model_directory/configuration.json。
- 一个字符串，托管在 huggingface.co 模型存储库中的预训练模型配置的模型 ID。有效的模型 ID 可以位于根级别，如
-
cache_dir(str或os.PathLike, 可选) — 下载的预训练模型配置应缓存在其中的目录路径，如果不使用标准缓存。 -
force_download(bool, 可选, 默认为False) — 是否强制（重新）下载配置文件并覆盖缓存版本（如果存在）。 -
resume_download(bool, 可选, 默认为False) — 是否删除接收不完整的文件。如果存在这样的文件，尝试恢复下载。 -
proxies(Dict[str, str], 可选) — 要使用的代理服务器字典，按协议或端点，例如，{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}。代理在每个请求上使用。 -
token(str或bool, 可选) — 用作远程文件的 HTTP bearer 授权的令牌。如果为True，或未指定，将使用运行huggingface-cli login时生成的令牌（存储在~/.huggingface）。 -
revision(str, 可选, 默认为"main") — 要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID，因为我们在 huggingface.co 上使用基于 git 的系统存储模型和其他工件，所以revision可以是 git 允许的任何标识符。 要测试您在 Hub 上提交的拉取请求，可以传递`revision=“refs/pr/<pr_number>“。</pr_number> -
return_unused_kwargs(bool, 可选, 默认为False) — 如果为False，则此函数仅返回最终配置对象。 如果为True，则此函数返回一个Tuple(config, unused_kwargs)，其中unused_kwargs是一个字典，由那些不是配置属性的键/值对组成：即，未用于更新config的kwargs部分，否则将被忽略。 -
subfolder(str, 可选, 默认为"") — 如果相关文件位于 huggingface.co 模型存储库的子文件夹中，您可以在此处指定文件夹名称。 -
kwargs(Dict[str, Any], 可选) — 任何键的 kwargs 值，这些键是配置属性，将用于覆盖加载的值。关于键/值对中键不是配置属性的行为由return_unused_kwargs关键字参数控制。
返回
PretrainedConfig
从此预训练模型实例化的配置对象。
从预训练模型配置实例化一个 PretrainedConfig（或派生类）。
示例：
# We can't instantiate directly the base class *PretrainedConfig* so let's show the examples on a
# derived class: BertConfig
config = BertConfig.from_pretrained(
"bert-base-uncased"
) # Download configuration from huggingface.co and cache.
config = BertConfig.from_pretrained(
"./test/saved_model/"
) # E.g. config (or model) was saved using *save_pretrained('./test/saved_model/')*
config = BertConfig.from_pretrained("./test/saved_model/my_configuration.json")
config = BertConfig.from_pretrained("bert-base-uncased", output_attentions=True, foo=False)
assert config.output_attentions == True
config, unused_kwargs = BertConfig.from_pretrained(
"bert-base-uncased", output_attentions=True, foo=False, return_unused_kwargs=True
)
assert config.output_attentions == True
assert unused_kwargs == {"foo": False}get_config_dict
( pretrained_model_name_or_path: Union **kwargs ) → export const metadata = 'undefined';Tuple[Dict, Dict]参数
pretrained_model_name_or_path(str或os.PathLike) — 我们想要参数字典的预训练检查点的标识符。
返回
Tuple[Dict, Dict]
将用于实例化配置对象的字典。
从pretrained_model_name_or_path解析为参数字典，用于使用from_dict实例化 PretrainedConfig。
register_for_auto_class
( auto_class = 'AutoConfig' )参数
auto_class(str或type, 可选, 默认为"AutoConfig") — 要将此新配置注册到的自动类。
使用给定的自动类注册此类。这仅应用于自定义配置，因为库中的配置已与AutoConfig映射。
此 API 是实验性的，可能在下一个版本中有一些轻微的破坏性更改。
save_pretrained
( save_directory: Union push_to_hub: bool = False **kwargs )参数
-
save_directory(str或os.PathLike) — 将保存配置 JSON 文件的目录（如果不存在将被创建）。 -
push_to_hub(bool, 可选, 默认为False) — 是否在保存后将模型推送到 Hugging Face 模型中心。您可以使用repo_id指定要推送到的存储库（将默认为您的命名空间中的save_directory的名称）。 -
kwargs(Dict[str, Any], 可选) — 传递给 push_to_hub() 方法的额外关键字参数。
将配置对象保存到目录 save_directory 中，以便可以使用 from_pretrained() 类方法重新加载。
to_dict
( ) → export const metadata = 'undefined';Dict[str, Any]返回
Dict[str, Any]
这个配置实例的所有属性的字典。
将此实例序列化为 Python 字典。
to_diff_dict
( ) → export const metadata = 'undefined';Dict[str, Any]返回
Dict[str, Any]
这个配置实例的所有属性的字典，
从配置中删除所有与默认配置属性对应的属性，以提高可读性并序列化为 Python 字典。
to_json_file
( json_file_path: Union use_diff: bool = True )参数
-
json_file_path(str或os.PathLike) — 此配置实例的参数将被保存在其中的 JSON 文件的路径。 -
use_diff(bool, 可选, 默认为True) — 如果设置为True，则只将配置实例与默认PretrainedConfig()之间的差异序列化为 JSON 文件。
将此实例保存到一个 JSON 文件。
to_json_string
( use_diff: bool = True ) → export const metadata = 'undefined';str参数
use_diff(bool, 可选, 默认为True) — 如果设置为True，则只将配置实例与默认PretrainedConfig()之间的差异序列化为 JSON 字符串。
返回
str
包含此配置实例中所有属性的字符串，以 JSON 格式。
将此实例序列化为 JSON 字符串。
update
( config_dict: Dict )参数
config_dict(Dict[str, Any]) — 应该更新此类的属性的字典。
使用config_dict中的属性更新此类的属性。
update_from_string
( update_str: str )参数
update_str(str) — 应该更新此类的属性的字符串。
使用update_str中的属性更新此类的属性。
预期的格式是整数、浮点数和字符串，对于布尔值，请使用 true 或 false。例如: “n_embd=10,resid_pdrop=0.2,scale_attn_weights=false,summary_type=cls_index”
要更改的键必须已经存在于配置对象中。
数据收集器
原文：
huggingface.co/docs/transformers/v4.37.2/en/main_classes/data_collator
数据收集器是通过使用数据集元素列表作为输入来形成批次的对象。这些元素与 train_dataset 或 eval_dataset 的元素类型相同。
为了能够构建批次，数据收集器可能会应用一些处理（如填充）。其中一些（如 DataCollatorForLanguageModeling）还会对形成的批次应用一些随机数据增强（如随机掩码）。
使用示例可在示例脚本或示例笔记本中找到。
默认数据收集器
transformers.default_data_collator
( features: List return_tensors = 'pt' )非常简单的数据收集器，只是将类似字典的对象的批次汇集在一起，并对名为潜在键执行特殊处理：
-
label: 处理每个对象的单个值（int 或 float） -
label_ids: 处理每个对象的值列表
不执行任何额外的预处理：输入对象的属性名称将用作模型的相应输入。查看 glue 和 ner 的示例，了解它的用途。
DefaultDataCollator
class transformers.DefaultDataCollator
( return_tensors: str = 'pt' )参数
return_tensors（str，可选，默认为"pt"）— 要返回的张量类型。允许的值为 “np”、"pt"和 “tf”。
非常简单的数据收集器，只是将类似字典的对象的批次汇集在一起，并对名为潜在键执行特殊处理：
-
label: 处理每个对象的单个值（int 或 float） -
label_ids: 处理每个对象的值列表
不执行任何额外的预处理：输入对象的属性名称将用作模型的相应输入。查看 glue 和 ner 的示例，了解它的用途。
这是一个对象（像其他数据收集器一样），而不是像 default_data_collator 那样的纯函数。如果需要在初始化时设置 return_tensors 值，这可能会有所帮助。
DataCollatorWithPadding
class transformers.DataCollatorWithPadding
( tokenizer: PreTrainedTokenizerBase padding: Union = True max_length: Optional = None pad_to_multiple_of: Optional = None return_tensors: str = 'pt' )参数
-
tokenizer（PreTrainedTokenizer 或 PreTrainedTokenizerFast）— 用于对数据进行编码的分词器。 -
padding（bool，str或 PaddingStrategy，可选，默认为True）— 选择一种策略来填充返回的序列（根据模型的填充方向和填充索引），包括：-
True或'longest'（默认）：填充到批次中最长的序列（如果只提供单个序列，则不填充）。 -
'max_length'：填充到指定的最大长度（使用参数max_length）或填充到模型的最大可接受输入长度（如果未提供该参数）。 -
False或'do_not_pad'：不填充（即，可以输出具有不同长度序列的批次）。
-
-
max_length（int，可选）— 返回列表的最大长度，可选填充长度（见上文）。 -
pad_to_multiple_of（int，可选）— 如果设置，将序列填充到提供的值的倍数。 这对于启用具有计算能力 >= 7.5（Volta）的 NVIDIA 硬件上的 Tensor Cores 的使用特别有用。 -
return_tensors（str，可选，默认为"pt"）— 要返回的张量类型。允许的值为 “np”、"pt"和 “tf”。
数据收集器，将动态填充接收到的输入。
DataCollatorForTokenClassification
class transformers.DataCollatorForTokenClassification
( tokenizer: PreTrainedTokenizerBase padding: Union = True max_length: Optional = None pad_to_multiple_of: Optional = None label_pad_token_id: int = -100 return_tensors: str = 'pt' )参数
-
tokenizer（PreTrainedTokenizer 或 PreTrainedTokenizerFast）— 用于对数据进行编码的分词器。 -
padding（bool，str或 PaddingStrategy，可选，默认为True）— 选择一种策略来填充返回的序列（根据模型的填充方向和填充索引），包括：-
True或'longest'（默认）：填充到批次中最长的序列（如果只提供单个序列，则不填充）。 -
'max_length'：填充到指定的最大长度（使用参数max_length）或模型的最大可接受输入长度（如果未提供该参数）。 -
False或'do_not_pad'：无填充（即，可以输出具有不同长度序列的批次）。
-
-
max_length（int，可选）— 返回列表的最大长度和可选填充长度（见上文）。 -
pad_to_multiple_of（int，可选）— 如果设置，将序列填充到提供的值的倍数。 这对于启用具有计算能力>= 7.5（Volta）的 NVIDIA 硬件上的 Tensor Cores 特别有用。 -
label_pad_token_id（int，可选，默认为-100）— 填充标签时要使用的 id（-100 将被 PyTorch 损失函数自动忽略）。 -
return_tensors（str，可选，默认为"pt"）— 要返回的 Tensor 类型。允许的值为“np”，"pt"和“tf”。
数据收集器，将动态填充接收到的输入以及标签。
DataCollatorForSeq2Seq
class transformers.DataCollatorForSeq2Seq
( tokenizer: PreTrainedTokenizerBase model: Optional = None padding: Union = True max_length: Optional = None pad_to_multiple_of: Optional = None label_pad_token_id: int = -100 return_tensors: str = 'pt' )参数
-
tokenizer（PreTrainedTokenizer 或 PreTrainedTokenizerFast）— 用于对数据进行编码的分词器。 -
model（PreTrainedModel，可选）— 正在训练的模型。如果设置并且具有prepare_decoder_input_ids_from_labels，则使用它来准备decoder_input_ids 这在使用label_smoothing时很有用，以避免计算损失两次。 -
padding（bool，str或 PaddingStrategy，可选，默认为True）— 选择一种策略来填充返回的序列（根据模型的填充方向和填充索引），包括：-
True或'longest'（默认）：填充到批次中最长的序列（如果只提供单个序列，则不填充）。 -
'max_length'：填充到指定的最大长度（使用参数max_length）或模型的最大可接受输入长度（如果未提供该参数）。 -
False或'do_not_pad'：无填充（即，可以输出具有不同长度序列的批次）。
-
-
max_length（int，可选）— 返回列表的最大长度和可选填充长度（见上文）。 -
pad_to_multiple_of（int，可选）— 如果设置，将序列填充到提供的值的倍数。 这对于启用具有计算能力>= 7.5（Volta）的 NVIDIA 硬件上的 Tensor Cores 特别有用。 -
label_pad_token_id（int，可选，默认为-100）— 填充标签时要使用的 id（-100 将被 PyTorch 损失函数自动忽略）。 -
return_tensors(str, optional, 默认为"pt") — 要返回的张量类型。允许的值为“np”，"pt"和“tf”。
数据收集器将动态填充接收到的输入和标签。
DataCollatorForLanguageModeling
class transformers.DataCollatorForLanguageModeling
( tokenizer: PreTrainedTokenizerBase mlm: bool = True mlm_probability: float = 0.15 pad_to_multiple_of: Optional = None tf_experimental_compile: bool = False return_tensors: str = 'pt' )参数
-
tokenizer（PreTrainedTokenizer 或 PreTrainedTokenizerFast） — 用于对数据进行编码的分词器。 -
mlm(bool, optional, 默认为True) — 是否使用遮罩语言建模。如果设置为False，则标签与输入相同，忽略填充标记（通过将它们设置为-100）。否则，对于未遮罩的标记，标签为-100，对于遮罩的标记，值为要预测的值。 -
mlm_probability(float, optional, 默认为 0.15) — 当mlm设置为True时，在输入中（随机）遮罩标记的概率。 -
pad_to_multiple_of(int, optional) — 如果设置，将序列填充到提供的值的倍数。 -
return_tensors(str) — 要返回的张量类型。允许的值为“np”，“pt”和“tf”。
用于语言建模的数据收集器。如果它们的长度不相同，则输入将动态填充到批次的最大长度。
为了获得最佳性能，应该将此数据收集器与具有字典或 BatchEncoding 项目的数据集一起使用，其中包含"special_tokens_mask"键，如由 PreTrainedTokenizer 或 PreTrainedTokenizerFast 返回的，参数return_special_tokens_mask=True。
numpy_mask_tokens
( inputs: Any special_tokens_mask: Optional = None )为遮罩语言建模准备遮罩标记输入/标签：80% MASK，10% 随机，10% 原始。
tf_mask_tokens
( inputs: Any vocab_size mask_token_id special_tokens_mask: Optional = None )为遮罩语言建模准备遮罩标记输入/标签：80% MASK，10% 随机，10% 原始。
torch_mask_tokens
( inputs: Any special_tokens_mask: Optional = None )为遮罩语言建模准备遮罩标记输入/标签：80% MASK，10% 随机，10% 原始。
DataCollatorForWholeWordMask
class transformers.DataCollatorForWholeWordMask
( tokenizer: PreTrainedTokenizerBase mlm: bool = True mlm_probability: float = 0.15 pad_to_multiple_of: Optional = None tf_experimental_compile: bool = False return_tensors: str = 'pt' )用于遮罩整个单词的语言建模数据收集器。
- 整理张量批次，尊重它们的分词器的 pad_token
- 为遮罩语言建模预处理批次
此数据收集器依赖于 BertTokenizer 对子词分词的实现细节，特别是子词标记以*##*为前缀。对于不遵循此方案的分词器，此数据收集器将产生一个大致等同于.DataCollatorForLanguageModeling的输出。
numpy_mask_tokens
( inputs: Any mask_labels: Any )为遮罩语言建模准备遮罩标记输入/标签：80% MASK，10% 随机，10% 原始。设置’mask_labels’表示我们使用整词遮罩（wwm），我们根据其引用直接遮罩 idxs。
tf_mask_tokens
( inputs: Any mask_labels: Any )为掩码语言建模准备掩码标记输入/标签：80%掩码，10%随机，10%原始。设置’mask_labels’表示我们使用整词掩码（wwm），我们根据其引用直接掩码 idxs。
torch_mask_tokens
( inputs: Any mask_labels: Any )为掩码语言建模准备掩码标记输入/标签：80%掩码，10%随机，10%原始。设置’mask_labels’表示我们使用整词掩码（wwm），我们根据其引用直接掩码 idxs。
DataCollatorForPermutationLanguageModeling
class transformers.DataCollatorForPermutationLanguageModeling
( tokenizer: PreTrainedTokenizerBase plm_probability: float = 0.16666666666666666 max_span_length: int = 5 return_tensors: str = 'pt' )用于排列语言建模的数据收集器。
- 整理张量批次，尊重其分词器的 pad_token
- 使用特定于 XLNet 的程序对排列语言建模进行预处理
numpy_mask_tokens
( inputs: Any )特定序列要预测的掩码标记由以下算法确定：
- 从序列开头开始，通过设置
cur_len = 0（到目前为止已处理的标记数）。 - 从区间
[1, max_span_length]中采样span_length（要掩码的标记跨度的长度） - 保留长度为
context_length = span_length / plm_probability的上下文以包围要掩码的跨度 - 从区间
[cur_len, cur_len + context_length - span_length]中采样起始点start_index并掩码标记start_index:start_index + span_length - 设置
cur_len = cur_len + context_length。如果cur_len < max_len（即序列中仍有剩余标记要处理），则从步骤 1 重复。
tf_mask_tokens
( inputs: Any )特定序列要预测的掩码标记由以下算法确定：
- 从序列开头开始，通过设置
cur_len = 0（到目前为止已处理的标记数）。 - 从区间
[1, max_span_length]中采样span_length（要掩码的标记跨度的长度） - 保留长度为
context_length = span_length / plm_probability的上下文以包围要掩码的跨度 - 从区间
[cur_len, cur_len + context_length - span_length]中采样起始点start_index并掩码标记start_index:start_index + span_length - 设置
cur_len = cur_len + context_length。如果cur_len < max_len（即序列中仍有剩余标记要处理），则从步骤 1 重复。
torch_mask_tokens
( inputs: Any )特定序列要预测的掩码标记由以下算法确定：
- 从序列开头开始，通过设置
cur_len = 0（到目前为止已处理的标记数）。 - 从区间
[1, max_span_length]中采样span_length（要掩码的标记跨度的长度） - 保留长度为
context_length = span_length / plm_probability的上下文以包围要掩码的跨度 - 从区间
[cur_len, cur_len + context_length - span_length]中采样起始点start_index并掩码标记start_index:start_index + span_length - 设置
cur_len = cur_len + context_length。如果cur_len < max_len（即序列中仍有剩余标记要处理），则从步骤 1 重复。
Keras 回调
在使用 Keras 训练 Transformers 模型时，有一些特定于库的回调可用于自动化常见任务：
KerasMetricCallback
class transformers.KerasMetricCallback
( metric_fn: Callable eval_dataset: Union output_cols: Optional = None label_cols: Optional = None batch_size: Optional = None predict_with_generate: bool = False use_xla_generation: bool = False generate_kwargs: Optional = None )参数
-
metric_fn（Callable）- 用户提供的度量函数。它将使用两个参数调用-predictions和labels。这些包含数据集中模型的输出和匹配标签。它应返回一个将度量名称映射到数值的字典。 -
eval_dataset（tf.data.Dataset或dict或tuple或np.ndarray或tf.Tensor）- 用于生成metric_fn预测的验证数据。 -
output_cols（List[str]，可选）- 从模型输出中保留的列的列表作为预测。默认为全部。 -
label_cols（List[str]，可选）- 从输入数据集中保留的列的列表作为标签。如果未提供，则将自动检测。 -
batch_size（int，可选）- 批量大小。仅在数据不是预先批处理的tf.data.Dataset时使用。 -
predict_with_generate（bool，可选，默认为False）- 是否应使用model.generate()来获取模型的输出。 -
use_xla_generation（bool，可选，默认为False）- 如果我们正在生成，是否使用 XLA 编译模型生成。这可以大大提高生成速度（最多提高 100 倍），但将需要为每个输入形状进行新的 XLA 编译。在使用 XLA 生成时，最好将输入填充到相同大小，或者在您的tokenizer或DataCollator中使用pad_to_multiple_of参数，这将减少唯一输入形状的数量并节省大量编译时间。如果predict_with_generate为False，则此选项不起作用。 -
generate_kwargs（dict，可选）- 生成时传递给model.generate()的关键字参数。如果predict_with_generate为False，则不起作用。
在每个时代结束时计算指标的回调。与普通的 Keras 指标不同，这些指标不需要由 TF 编译。对于像 BLEU 和 ROUGE 这样需要字符串操作或无法编译的生成循环的常见 NLP 指标，这是特别有用的。在将预测（或生成）传递给metric_fn之前，将在eval_dataset上计算预测（或生成）并以np.ndarray格式传递给metric_fn。metric_fn应计算指标并返回将度量名称映射到度量值的字典。
我们在下面提供了一个适合的 metric_fn 示例，用于计算摘要模型的 ROUGE 分数。请注意，为了可读性和简单起见，此示例跳过了一些后处理步骤，可能不应直接使用！
from datasets import load_metric
rouge_metric = load_metric("rouge")
def rouge_fn(predictions, labels):
decoded_predictions = tokenizer.batch_decode(predictions, skip_special_tokens=True)
decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
result = rouge_metric.compute(predictions=decoded_predictions, references=decoded_labels)
return {key: value.mid.fmeasure * 100 for key, value in result.items()}上述函数将返回一个包含值的字典，这些值将像其他 Keras 指标一样被记录：
{'rouge1': 37.4199, 'rouge2': 13.9768, 'rougeL': 34.361, 'rougeLsum': 35.0781PushToHubCallback
class transformers.PushToHubCallback
( output_dir: Union save_strategy: Union = 'epoch' save_steps: Optional = None tokenizer: Optional = None hub_model_id: Optional = None hub_token: Optional = None checkpoint: bool = False **model_card_args )参数
-
output_dir（str）- 模型预测和检查点将被写入并与 Hub 上的存储库同步的输出目录。 -
save_strategy（str或 IntervalStrategy，可选，默认为"epoch"）- 训练期间采用的检查点保存策略。可能的值为：-
"no"：保存在训练结束时完成。 -
"epoch"：在每个时代结束时完成保存。 -
"steps"：每save_steps完成保存
-
-
save_steps（int，可选）- 使用“steps”save_strategy时保存之间的步数。 -
tokenizer（PreTrainedTokenizerBase，可选）—模型使用的分词器。如果提供，将与权重一起上传到存储库。 -
hub_model_id（str，可选）—要与本地output_dir同步的存储库的名称。它可以是一个简单的模型 ID，此时模型将被推送到您的命名空间。否则，它应该是整个存储库名称，例如"user_name/model"，这样您就可以推送到您所属的组织，例如"organization_name/model"。 将默认为output_dir的名称。 -
hub_token（str，可选）—用于将模型推送到 Hub 的令牌。将默认为使用huggingface-cli login获取的缓存文件夹中的令牌。 -
checkpoint（bool，可选，默认为False）—是否保存完整的训练检查点（包括 epoch 和优化器状态），以允许恢复训练。仅在save_strategy为"epoch"时可用。
回调函数将定期保存并推送模型到 Hub。默认情况下，它每个 epoch 推送一次，但可以使用save_strategy参数进行更改。推送的模型可以像 Hub 上的任何其他模型一样访问，例如使用from_pretrained方法。
from transformers.keras_callbacks import PushToHubCallback
push_to_hub_callback = PushToHubCallback(
output_dir="./model_save",
tokenizer=tokenizer,
hub_model_id="gpt5-7xlarge",
)
model.fit(train_dataset, callbacks=[push_to_hub_callback])日志记录
原始文本：
huggingface.co/docs/transformers/v4.37.2/en/main_classes/logging
🤗 Transformers 具有集中的日志记录系统，因此您可以轻松设置库的详细程度。
目前库的默认详细程度为WARNING。
要更改详细程度，请使用其中一个直接设置器。例如，以下是如何将详细程度更改为 INFO 级别。
import transformers
transformers.logging.set_verbosity_info()您还可以使用环境变量TRANSFORMERS_VERBOSITY来覆盖默认的详细程度。您可以将其设置为以下之一：debug，info，warning，error，critical。例如：
TRANSFORMERS_VERBOSITY=error ./myprogram.py此外，通过将环境变量TRANSFORMERS_NO_ADVISORY_WARNINGS设置为真值（如1），可以禁用一些warnings。这将禁用使用logger.warning_advice记录的任何警告。例如：
TRANSFORMERS_NO_ADVISORY_WARNINGS=1 ./myprogram.py以下是如何在您自己的模块或脚本中使用与库相同的记录器的示例：
from transformers.utils import logging
logging.set_verbosity_info()
logger = logging.get_logger("transformers")
logger.info("INFO")
logger.warning("WARN")此日志记录模块的所有方法都在下面有文档记录，主要方法是 logging.get_verbosity()用于获取记录器中当前详细程度的级别和 logging.set_verbosity()用于将详细程度设置为您选择的级别。按顺序（从最不详细到最详细），这些级别（及其相应的整数值）为：
-
transformers.logging.CRITICAL或transformers.logging.FATAL（整数值，50）：仅报告最关键的错误。 -
transformers.logging.ERROR（整数值，40）：仅报告错误。 -
transformers.logging.WARNING或transformers.logging.WARN（整数值，30）：仅报告错误和警告。这是库使用的默认级别。 -
transformers.logging.INFO（整数值，20）：报告错误，警告和基本信息。 -
transformers.logging.DEBUG（整数值，10）：报告所有信息。
默认情况下，在模型下载期间将显示tqdm进度条。logging.disable_progress_bar()和 logging.enable_progress_bar()可用于抑制或取消抑制此行为。
日志记录与警告
Python 有两个经常一起使用的日志记录系统：logging，如上所述，和warnings，允许进一步对警告进行分类，例如，FutureWarning用于已经被弃用的功能或路径，DeprecationWarning用于指示即将被弃用的内容。
我们在transformers库中同时使用这两种。我们利用并调整logging的captureWarning方法，以允许通过上述详细程度设置器管理这些警告消息。
这对库的开发人员意味着什么？我们应该遵守以下启发式：
-
warnings应该优先考虑库的开发人员和依赖于transformers的库。 -
logging应该用于每天项目中使用该库的最终用户
请参阅下面的captureWarnings方法的参考。
transformers.utils.logging.captureWarnings
( capture )调用logging库中的captureWarnings方法，以启用对warnings库发出的警告的管理。
在此处阅读有关此方法的更多信息：docs.python.org/3/library/logging.html#integration-with-the-warnings-module
所有警告都将通过py.warnings记录器记录。
注意：如果此记录器尚未具有处理程序，则此方法还会向此记录器添加处理程序，并将该记录器的记录级别更新为库的根记录器。
基本设置器
transformers.utils.logging.set_verbosity_error
( )将详细程度设置为ERROR级别。
transformers.utils.logging.set_verbosity_warning
( )将详细程度设置为WARNING级别。
transformers.utils.logging.set_verbosity_info
( )将详细程度设置为INFO级别。
transformers.utils.logging.set_verbosity_debug
( )将详细程度设置为DEBUG级别。
其他函数
transformers.utils.logging.get_verbosity
( ) → export const metadata = 'undefined';int返回
int
记录级别。
以 int 形式返回🤗 Transformers 的根记录器的当前级别。
🤗 Transformers 有以下记录级别：
- 50：
transformers.logging.CRITICAL或transformers.logging.FATAL - 40：
transformers.logging.ERROR - 30：
transformers.logging.WARNING或transformers.logging.WARN - 20：
transformers.logging.INFO - 10：
transformers.logging.DEBUG
transformers.utils.logging.set_verbosity
( verbosity: int )参数
-
verbosity（int）— 记录级别，例如：-
transformers.logging.CRITICAL或transformers.logging.FATAL -
transformers.logging.ERROR -
transformers.logging.WARNING或transformers.logging.WARN -
transformers.logging.INFO -
transformers.logging.DEBUG
-
为🤗 Transformers 的根记录器设置详细程度级别。
transformers.utils.logging.get_logger
( name: Optional = None )返回具有指定名称的记录器。
这个功能不应该直接访问，除非你正在编写一个自定义的 transformers 模块。
transformers.utils.logging.enable_default_handler
( )启用 HuggingFace Transformers 的根记录器的默认处理程序。
transformers.utils.logging.disable_default_handler
( )禁用 HuggingFace Transformers 的根记录器的默认处理程序。
transformers.utils.logging.enable_explicit_format
( )为每个 HuggingFace Transformers 的记录器启用显式格式。显式格式如下：
[LEVELNAME|FILENAME|LINE NUMBER] TIME >> MESSAGE此方法影响当前绑定到根记录器的所有处理程序。#### transformers.utils.logging.reset_format
( )重置 HuggingFace Transformers 的记录格式。
此方法影响当前绑定到根记录器的所有处理程序。
transformers.utils.logging.enable_progress_bar
( )启用 tqdm 进度条。
transformers.utils.logging.disable_progress_bar
( )禁用 tqdm 进度条。
模型
huggingface.co/docs/transformers/v4.37.2/en/main_classes/model
基类 PreTrainedModel、TFPreTrainedModel 和 FlaxPreTrainedModel 实现了从本地文件或目录加载/保存模型的常用方法，或从库提供的预训练模型配置（从 HuggingFace 的 AWS S3 存储库下载）加载模型。
PreTrainedModel 和 TFPreTrainedModel 还实现了一些所有模型共有的方法：
- 当新的标记添加到词汇表中时，调整输入标记嵌入大小
- 修剪模型的注意力头。
每个模型共有的其他方法在 ModuleUtilsMixin（用于 PyTorch 模型）和 ~modeling_tf_utils.TFModuleUtilsMixin（用于 TensorFlow 模型）中定义，或者用于文本生成的 GenerationMixin（用于 PyTorch 模型）、TFGenerationMixin（用于 TensorFlow 模型）和 FlaxGenerationMixin（用于 Flax/JAX 模型）。
PreTrainedModel
class 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("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 的模型中。不会覆盖模型中的现有标签。
示例：
from transformers import AutoModel
model = AutoModel.from_pretrained("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
( ) → export const metadata = 'undefined';bool返回
bool
此模型是否可以生成序列，使用.generate()。
返回此模型是否可以生成序列，使用.generate()。
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。有效的模型 ID 可以位于根级别，如
bert-base-uncased，或者在用户或组织名称下命名空间化，如dbmdz/bert-base-german-cased。 - 指向包含使用 save_pretrained()保存的模型权重的目录的路径，例如，
./my_model_directory/。 - 指向TensorFlow 索引检查点文件的路径或 URL（例如，
./tf_model/model.ckpt.index）。在这种情况下，应将from_tf设置为True，并将配置对象作为config参数提供。使用此加载路径比使用提供的转换脚本将 TensorFlow 检查点转换为 PyTorch 模型并随后加载 PyTorch 模型要慢。 - 一个包含flax checkpoint file的模型文件夹的路径或 url，格式为*.msgpack*（例如，
./flax_model/包含flax_model.msgpack）。在这种情况下，from_flax应设置为True。 - 如果您同时提供配置和状态字典（分别使用关键字参数
config和state_dict），则为None。
- 一个字符串，托管在 huggingface.co 模型存储库中的预训练模型的模型 ID。有效的模型 ID 可以位于根级别，如
-
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（bool，可选，默认为False) — 是否删除接收不完整的文件。如果存在这样的文件，将尝试恢复下载。 -
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 允许的任何标识符。 要测试您在 Hub 上创建的拉取请求，可以传递 `revision=“refs/pr/<pr_number>“。</pr_number> -
mirror(str, 可选) — 镜像源以加速中国的下载。如果您来自中国并且有访问问题，您可以设置此选项来解决。请注意，我们不保证及时性或安全性。请参考镜像站点获取更多信息。 -
_fast_init(bool,可选, 默认为True) — 是否禁用快速初始化。 为了确保与transformers.__version__ < 4.6.0的种子模型初始化向后兼容，应该只禁用 _fast_init。此参数将在下一个主要版本中删除。有关更多信息，请参阅拉取请求 11471。
大型模型推理的参数
-
low_cpu_mem_usage(bool,可选) — 尝试在加载模型时不使用超过 CPU 内存中的 1x 模型大小（包括峰值内存）。这是一个实验性功能，随时可能更改。 -
torch_dtype(str或torch.dtype, 可选) — 覆盖默认的torch.dtype并在特定的dtype下加载模型。不同的选项有：-
torch.float16或torch.bfloat16或torch.float: 以指定的dtype加载，忽略模型的config.torch_dtype（如果存在）。如果未指定- 模型将以
torch.float(fp32) 加载。
- 模型将以
-
"auto"- 将尝试使用模型的config.json文件中的torch_dtype条目。如果找不到此条目，则下一个检查是检查点中第一个浮点类型的权重的dtype并将其用作dtype。这将使用模型在训练结束时保存的dtype加载模型。它不能用作模型训练方式的指示器。因为它可能是在半精度dtype中训练，但以 fp32 保存。
对于一些模型，它们训练时使用的
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, 可选) — 设备标识符到最大内存的字典。如果未设置，将默认为每个 GPU 可用的最大内存和可用的 CPU RAM。 -
offload_folder(str或os.PathLike, 可选) — 如果device_map包含任何值"disk"，则我们将卸载权重的文件夹。 -
offload_state_dict(bool, 可选) — 如果为True，将临时将 CPU 状态字典转移到硬盘，以避免 CPU RAM 不足，如果 CPU 状态字典的重量 + 检查点的最大分片不适合。当存在一些磁盘卸载时，默认为True。 -
load_in_8bit(bool, optional, 默认为False) — 如果为True，将加载的模型转换为混合 8 位量化模型。要使用此功能，请安装bitsandbytes（pip install -U bitsandbytes）。 -
load_in_4bit(bool, optional, 默认为False) — 如果为True，将加载的模型转换为 4 位精度量化模型。要使用此功能，请安装最新版本的bitsandbytes（pip install -U bitsandbytes）。 -
quantization_config(Union[QuantizationConfigMixin,Dict], 可选) — 量化的配置参数字典或 QuantizationConfigMixin 对象（例如 bitsandbytes, gptq） -
subfolder(str, optional, 默认为"") — 如果相关文件位于 huggingface.co 模型仓库的子文件夹中，您可以在这里指定文件夹名称。 -
variant(str, optional) — 如果指定，将从variant文件名加载权重，例如 pytorch_model..bin。在使用from_tf或from_flax时忽略variant。 -
use_safetensors(bool, optional, 默认为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()将其设置回训练模式。
警告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("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("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("bert-base-uncased", from_flax=True)low_cpu_mem_usage算法：
这是一个使用约 1 倍模型大小 CPU 内存加载模型的实验性功能
以下是它的工作原理：
- 保存我们拥有的 state_dict 键
- 在创建模型之前删除 state_dict，因为后者需要 1 倍模型大小的 CPU 内存
- 在实例化模型后，切换到元设备，所有将从加载的 state_dict 中替换的参数/缓冲区
- 第二次加载 state_dict
- 从 state_dict 中替换参数/缓冲区
目前，它无法处理 deepspeed ZeRO 阶段 3 并忽略加载错误
get_input_embeddings
( ) → export const metadata = 'undefined';nn.Module返回
nn.Module
将词汇映射到隐藏状态的 torch 模块。
返回模型的输入嵌入。
get_memory_footprint
( return_buffers = True )参数
return_buffers（bool，可选，默认为True）— 是否在计算内存占用时返回缓冲张量的大小。缓冲区是不需要梯度且未注册为参数的张量。例如，批量归一化层中的均值和标准差。请参见：discuss.pytorch.org/t/what-pytorch-means-by-buffers/120266/2
获取模型的内存占用。这将以字节为单位返回当前模型的内存占用。有助于基准测试当前模型的内存占用并设计一些测试。解决方案灵感来自 PyTorch 讨论：discuss.pytorch.org/t/gpu-memory-that-model-uses/56822/2
get_output_embeddings
( ) → export const metadata = 'undefined';nn.Module返回
nn.Module
将隐藏状态映射到词汇表的 torch 模块。
返回模型的输出嵌入。
gradient_checkpointing_disable
( )为当前模型停用梯度检查点。
请注意，在其他框架中，此功能可能被称为“激活检查点”或“检查点激活”。
gradient_checkpointing_enable
( gradient_checkpointing_kwargs = None )参数
gradient_checkpointing_kwargs（字典，可选）— 传递给torch.utils.checkpoint.checkpoint函数的附加关键字参数。
为当前模型激活梯度检查点。
请注意，在其他框架中，此功能可能被称为“激活检查点”或“检查点激活”。
我们传递模块的__call__方法而不是forward，因为__call__会附加模块的所有钩子。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 ) → export const metadata = 'undefined';torch.nn.Embedding参数
-
new_num_tokens(int, optional) — 嵌入矩阵中的新标记数。增加大小将在末尾添加新初始化的向量。减小大小将从末尾删除向量。如果未提供或为None，则只返回指向模型的输入标记torch.nn.Embedding模块的指针，而不执行任何操作。 -
pad_to_multiple_of(int, optional) — 如果设置，将填充嵌入矩阵到提供的值的倍数。如果new_num_tokens设置为None，则只会将嵌入填充到pad_to_multiple_of的倍数。 这对于启用 NVIDIA 硬件上的 Tensor Cores 特别有用，计算能力>= 7.5（Volta），或者对于受益于序列长度为 128 的倍数的 TPUs。有关此更多详细信息，或者有关选择调整大小的正确值的帮助，请参阅此指南：docs.nvidia.com/deeplearning/performance/dl-performance-matrix-multiplication/index.html#requirements-tc
返回
torch.nn.Embedding
指向模型的输入标记嵌入模块。
如果new_num_tokens != config.vocab_size，则调整模型的输入标记嵌入矩阵的大小。
在模型类具有tie_weights()方法时负责绑定权重嵌入。
reverse_bettertransformer
( ) → export const metadata = 'undefined';PreTrainedModel返回
PreTrainedModel
将模型转换回原始建模。
撤消从 to_bettertransformer()的转换，以便使用原始建模，例如为了保存模型。
save_pretrained
( save_directory: Union is_main_process: bool = True state_dict: Optional = None save_function: Callable = <function save at 0x7f3c5f9b0160> 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, optional, 默认为True) — 调用此函数的进程是否为主进程。在像 TPU 这样的分布式训练中很有用，需要在所有进程上调用此函数。在这种情况下，仅在主进程上设置is_main_process=True，以避免竞争条件。 -
state_dict（torch.Tensor的嵌套字典） — 要保存的模型的状态字典。将默认为self.state_dict()，但可以用于仅保存模型的部分或者在恢复模型的状态字典时需要采取特殊预防措施的情况（例如在使用模型并行时）。 -
save_function(Callable) — 用于保存状态字典的函数。在像 TPU 这样的分布式训练中很有用，当需要用另一种方法替换torch.save时。 -
push_to_hub(bool, optional, 默认为False) — 是否在保存后将模型推送到 Hugging Face 模型中心。您可以使用repo_id指定要推送到的存储库（将默认为您的命名空间中的save_directory的名称）。 -
max_shard_size(int或str，optional，默认为"5GB") — 在分片之前的检查点的最大大小。然后，检查点分片的大小将小于此大小。如果表示为字符串，需要是数字后跟一个单位（如"5MB"）。我们将其默认为 5GB，以便模型能够在免费的 Google Colab 实例上轻松运行，而不会出现 CPU OOM 问题。 如果模型的单个权重大于max_shard_size，则它将在自己的检查点分片中，该分片将大于max_shard_size。 -
safe_serialization(bool, optional, 默认为True) — 是否使用safetensors或传统的 PyTorch 方式（使用pickle）保存模型。 -
variant(str, 可选) — 如果指定，权重将以 pytorch_model..bin 的格式保存。 -
token(str或bool, 可选) — 用作远程文件的 HTTP bearer 授权的令牌。如果为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
( ) → export const metadata = 'undefined';PreTrainedModel返回
PreTrainedModel
转换为 BetterTransformer 的模型。
将模型转换为使用PyTorch 的本机注意力实现，通过Optimum 库集成到 Transformers 中。仅支持所有 Transformers 模型的子集。
PyTorch 的注意力快速路径允许通过内核融合和使用嵌套张量加速推理。详细的基准测试可以在这篇博文中找到。
warn_if_padding_and_no_attention_mask
( input_ids attention_mask )如果输入的 input_ids 看起来包含填充并且没有给出注意力掩码，则显示一次警告。
大型模型加载
在 Transformers 4.20.0 中，from_pretrained() 方法已经重新设计，以适应使用Accelerate的大型模型。这需要 Accelerate >= 0.9.0 和 PyTorch >= 1.9.0。与其在内存中创建完整模型，然后加载预训练权重（这需要模型大小的两倍的内存，一个用于随机初始化模型，一个用于权重），现在有一个选项可以创建模型作为空壳，然后只有在加载预训练权重时才实现其参数。
可以通过 low_cpu_mem_usage=True 激活此选项。模型首先在 Meta 设备上创建（带有空权重），然后状态字典被加载到其中（在分片检查点的情况下逐个分片）。这样，最大使用的 RAM 仅为模型的完整大小。
from transformers import AutoModelForSeq2SeqLM
t0pp = AutoModelForSeq2SeqLM.from_pretrained("bigscience/T0pp", low_cpu_mem_usage=True)此外，如果模型无法完全适应 RAM（目前仅适用于推断），则可以直接将模型放置在不同的设备上。使用device_map="auto"，Accelerate 将确定将每个层放置在哪里以最大化您最快的设备（GPU）的使用，并将其余部分卸载到 CPU，甚至硬盘，如果您没有足够的 GPU RAM（或 CPU RAM）。即使模型分布在多个设备上，它也将按照您通常的预期运行。
在传递device_map时，low_cpu_mem_usage会自动设置为True，因此您无需指定它：
from transformers import AutoModelForSeq2SeqLM
t0pp = AutoModelForSeq2SeqLM.from_pretrained("bigscience/T0pp", device_map="auto")您可以查看hf_device_map属性来查看模型如何分布在设备上：
t0pp.hf_device_map{'shared': 0,
'decoder.embed_tokens': 0,
'encoder': 0,
'decoder.block.0': 0,
'decoder.block.1': 1,
'decoder.block.2': 1,
'decoder.block.3': 1,
'decoder.block.4': 1,
'decoder.block.5': 1,
'decoder.block.6': 1,
'decoder.block.7': 1,
'decoder.block.8': 1,
'decoder.block.9': 1,
'decoder.block.10': 1,
'decoder.block.11': 1,
'decoder.block.12': 1,
'decoder.block.13': 1,
'decoder.block.14': 1,
'decoder.block.15': 1,
'decoder.block.16': 1,
'decoder.block.17': 1,
'decoder.block.18': 1,
'decoder.block.19': 1,
'decoder.block.20': 1,
'decoder.block.21': 1,
'decoder.block.22': 'cpu',
'decoder.block.23': 'cpu',
'decoder.final_layer_norm': 'cpu',
'decoder.dropout': 'cpu',
'lm_head': 'cpu'}您还可以按照相同格式编写自己的设备映射（将层名称映射到设备的字典）。它应该将模型的所有参数映射到给定设备，但如果该层完全位于同一设备上，则不必详细说明一个层的所有子模块去哪里。例如，以下设备映射对于 T0pp 将正常工作（只要您有 GPU 内存）：
device_map = {"shared": 0, "encoder": 0, "decoder": 1, "lm_head": 1}减少模型内存影响的另一种方法是以较低精度 dtype（如torch.float16）实例化模型，或者使用下面描述的直接量化技术。
模型实例化 dtype
在 Pytorch 下，模型通常以torch.float32格式实例化。如果尝试加载权重为 fp16 的模型，则可能会出现问题，因为它将需要两倍的内存。为了克服这个限制，您可以使用torch_dtype参数显式传递所需的dtype：
model = T5ForConditionalGeneration.from_pretrained("t5", torch_dtype=torch.float16)或者，如果希望模型始终以最佳内存模式加载，可以使用特殊值"auto"，然后dtype将自动从模型的权重中派生：
model = T5ForConditionalGeneration.from_pretrained("t5", torch_dtype="auto")从头开始实例化的模型也可以指定使用的dtype：
config = T5Config.from_pretrained("t5")
model = AutoModel.from_config(config)由于 Pytorch 设计，此功能仅适用于浮点 dtype。
ModuleUtilsMixin
class transformers.modeling_utils.ModuleUtilsMixin
( )用作 mixin 的torch.nn.Modules的一些实用程序。
add_memory_hooks
( )在每个子模块正向传递之前和之后添加内存钩子以记录内存消耗的增加。
内存消耗的增加存储在每个模块的mem_rss_diff属性中，并可以使用model.reset_memory_hooks_state()将其重置为零。
estimate_tokens
( input_dict: Dict ) → export const metadata = 'undefined';int参数
inputs（dict）— 模型输入。
返回
int
令牌的总数。
用于估计模型输入中总令牌数的辅助函数。
floating_point_ops
( input_dict: Dict exclude_embeddings: bool = True ) → export const metadata = 'undefined';int参数
-
batch_size（int）— 正向传递的批量大小。 -
sequence_length（int）— 每个批次行中的令牌数。 -
exclude_embeddings（bool，可选，默认为True）— 是否计算嵌入和 softmax 操作。
返回
int
浮点运算的数量。
使用此转换器模型的批处理的正向和反向传递的浮点操作的数量（可选，非嵌入）。默认近似忽略对令牌数量的二次依赖（如果12 * d_model << sequence_length）如本文第 2.1 节所述。对于具有参数重用的变压器（例如 Albert 或通用变压器）或者如果使用非常高的序列长度进行长距离建模，则应该进行覆盖。
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 ) → export const metadata = 'undefined';torch.Tensor参数
encoder_attention_mask(torch.Tensor) — 一个注意力掩码。
返回
torch.Tensor
反转的注意力掩码。
反转注意力掩码（例如，切换 0 和 1）。
num_parameters
( only_trainable: bool = False exclude_embeddings: bool = False ) → export const metadata = 'undefined';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，可选）— 是否应创建私有存储库。 -
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 或直接提交。
将模型文件上传到🤗模型 Hub，同时同步存储库的本地克隆到repo_path_or_name中。
示例：
from transformers import TFAutoModel
model = TFAutoModel.from_pretrained("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
( ) → export const metadata = 'undefined';bool返回
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 )这是一个薄包装器，如果用户没有指定自己的损失函数，则将模型的损失输出头设置为损失。
create_model_card
( 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 上的 repo，则默认为使用的预训练模型的许可证。 -
tags（str或List[str]，可选）— 要包含在模型卡片的元数据中的一些标签。 -
finetuned_from（str，可选）— 用于微调此模型的模型的名称（如果适用）。如果来自 Hub 的原始模型的Trainer给出的 repo 的名称，则默认为原始模型的名称。 -
tasks（str或List[str]，可选）— 一个或多个任务标识符，要包含在模型卡片的元数据中。 -
dataset_tags（str或List[str]，可选）— 一个或多个数据集标签，要包含在模型卡片的元数据中。 -
dataset（str或List[str]，可选）— 一个或多个数据集标识符，要包含在模型卡片的元数据中。 -
dataset_args（str或List[str]，可选）— 一个或多个数据集参数，要包含在模型卡片的元数据中。
使用Trainer可用的信息创建模型卡片的草稿。
eager_serving
( inputs )参数
inputs（Dict[str, tf.Tensor]）— 保存模型的输入，作为张量字典。
用于提供模型的方法。此方法已弃用，将被移除。
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，可选）— 可以是：- 一个字符串，预训练模型的模型 id，托管在 huggingface.co 上的模型存储库中。有效的模型 id 可以位于根级别，如
bert-base-uncased，或者在用户或组织名称下命名空间，如dbmdz/bert-base-german-cased。 - 一个目录的路径，其中包含使用 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。
- 一个字符串，预训练模型的模型 id，托管在 huggingface.co 上的模型存储库中。有效的模型 id 可以位于根级别，如
-
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(bool, 可选, 默认为False) — 是否删除接收不完整的文件。如果存在这样的文件，将尝试恢复下载。代理 — (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 的权重不是与模型的其余部分一起预训练的。您需要使用下游微调任务来训练这些权重。
警告来自 XXX 的权重在 YYY 中未使用表示层 XXX 未被 YYY 使用，因此这些权重被丢弃。
示例：
>>> from transformers import BertConfig, TFBertModel
>>> # Download model and configuration from huggingface.co and cache.
>>> model = TFBertModel.from_pretrained("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("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
( ) → export const metadata = 'undefined';tf.Variable返回
tf.Variable
表示偏置的权重，如果不是 LM 模型则为 None。
附加到 LM head 的偏置的字典。键表示偏置属性的名称。
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
( ) → export const metadata = 'undefined';tf.Variable返回
tf.Variable
将词汇映射到隐藏状态的嵌入层。
返回模型的输入嵌入层。
get_lm_head
( ) → export const metadata = 'undefined';tf.keras.layers.Layer返回
tf.keras.layers.Layer
如果模型有 LM head 层，则为 LM head 层，否则为 None。
LM Head 层。该方法必须被所有具有 lm head 的模型覆盖。
get_output_embeddings
( ) → export const metadata = 'undefined';tf.Variable返回
tf.Variable
将词汇映射到隐藏状态的新权重。
返回模型的输出嵌入
get_output_layer_with_bias
( ) → export const metadata = 'undefined';tf.keras.layers.Layer返回
tf.keras.layers.Layer
处理偏置的层，如果不是 LM 模型则为 None。
获取处理偏置属性的层，如果模型具有将权重绑定到嵌入的 LM head
get_prefix_bias_name
( ) → export const metadata = 'undefined';str返回
str
偏置的连接前缀名称。
从模型名称到父层的偏置的连接前缀名称
load_repo_checkpoint
( repo_path_or_name ) → export const metadata = 'undefined';dict参数
repo_path_or_name(str) — 可以是 Hub 中您的 {object} 的存储库名称，也可以是本地文件夹的路径（在这种情况下，存储库将使用该本地文件夹的名称）。
返回
dict
来自检查点的额外元数据字典，通常是“时代”计数。
从存储库加载已保存的检查点（模型权重和优化器状态）。返回检查点生成时的当前时代计数。
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 ) → export const metadata = 'undefined';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管道的末尾添加预取。这几乎总是有利于性能，但在边缘情况下可以禁用。
返回
Dataset
一个准备传递给 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") — 要注册此新模型的自动类。
使用给定的自动类注册此类。这应仅用于自定义模型，因为库中的模型已经与自动类映射。
此 API 是实验性的，可能在下一个版本中有一些轻微的破坏性更改。
resize_token_embeddings
( new_num_tokens: Optional[int] = None ) → export const metadata = 'undefined';tf.Variable or tf.keras.layers.Embedding参数
new_num_tokens(int, 可选) — 嵌入矩阵中的新标记数量。增加大小将在末尾添加新初始化的向量。减小大小将从末尾删除向量。如果未提供或为None，则只返回指向输入标记的指针，而不执行任何操作。
返回
tf.Variable 或 tf.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] = '10GB' create_pr: bool = False safe_serialization: bool = False token: Optional[Union[str, bool]] = None **kwargs )参数
-
save_directory(str) — 要保存到的目录。如果不存在，将创建该目录。 -
saved_model(bool, 可选, 默认为False) — 是否还要将模型保存为 saved model 格式。 -
version(int, 可选, 默认为 1) — 已保存模型的版本。为了能够被 TensorFlow Serving 正确加载，保存的模型需要进行版本化，详细信息请参阅官方文档www.tensorflow.org/tfx/serving/serving_basic -
push_to_hub(bool, 可选, 默认为False) — 是否在保存后将模型推送到 Hugging Face 模型中心。您可以使用repo_id指定要推送到的存储库（将默认为您的命名空间中的save_directory名称）。 -
signatures(dict或tf.function, 可选) — 用于 serving 的模型签名。这将传递给 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保存时的functions。 - 输入（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
class transformers.modeling_tf_utils.TFModelUtilsMixin
( )用于 tf.keras.Model 的一些实用程序，可用作混合。
num_parameters
( only_trainable: bool = False ) → export const metadata = 'undefined';int参数
only_trainable(bool, optional, 默认为False) — 是否仅返回可训练参数的数量
返回
int
参数数量。
获取模型中的（可选的可训练）参数数量。
FlaxPreTrainedModel
class 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, optional) — 是否使用临时目录存储在推送到 Hub 之前保存的文件。如果没有名为repo_id的目录，则默认为True，否则为False。 -
commit_message(str, optional) — 推送时要提交的消息。默认为"Upload model"。 -
private(bool, optional) — 是否创建的存储库应为私有。 -
token(bool或str, optional) — 用作远程文件的 HTTP bearer 授权的令牌。如果为True，将使用运行huggingface-cli login时生成的令牌（存储在~/.huggingface中）。如果未指定repo_url，则默认为True。 -
max_shard_size(int或str, optional, 默认为"5GB") — 仅适用于模型。在被分片之前的检查点的最大大小。然后检查点将被分成小于此大小的每个部分。如果表示为字符串，需要是数字后跟一个单位（如"5MB"）。我们将其默认为"5GB"，以便用户可以在免费的 Google Colab 实例上轻松加载模型，而不会出现任何 CPU OOM 问题。 -
create_pr(bool, optional, 默认为False) — 是否创建一个带有上传文件的 PR 或直接提交。 -
safe_serialization(bool, optional, 默认为True) — 是否将模型权重转换为 safetensors 格式以进行更安全的序列化。 -
revision(str, optional) — 要将上传的文件推送到的分支。 -
commit_description(str, optional) — 将要创建的提交的描述 -
tags(List[str], optional) — 要推送到 Hub 上的标签列表。
上传模型检查点到 🤗 Model Hub。
示例：
from transformers import FlaxAutoModel
model = FlaxAutoModel.from_pretrained("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。有效的模型 ID 可以位于根级别，如
bert-base-uncased，或者在用户或组织名称下命名空间化，如dbmdz/bert-base-german-cased。 - 一个包含使用 save_pretrained()保存的模型权重的目录路径，例如，
./my_model_directory/。 - pt 索引检查点文件的路径或 URL（例如，
./tf_model/model.ckpt.index）。在这种情况下，from_pt应设置为True。
- 一个字符串，托管在 huggingface.co 模型存储库中的预训练模型的模型 ID。有效的模型 ID 可以位于根级别，如
-
dtype(jax.numpy.dtype, optional, 默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。 这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了dtype，则所有计算将使用给定的dtype执行。请注意，这仅指定计算的数据类型，不影响模型参数的数据类型。如果要更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。 -
model_args（位置参数序列，optional） — 所有剩余的位置参数将传递给底层模型的__init__方法。 -
config(Union[PretrainedConfig, str, os.PathLike], optional) — 可以是：- 从 PretrainedConfig 派生的类的实例，
- 一个作为 from_pretrained()输入有效的字符串或路径。
要使用的模型配置，而不是自动加载的配置。当以下情况自动加载配置时：
- 模型是库提供的模型（使用预训练模型的模型 ID字符串加载）。
- 模型是使用 save_pretrained()保存的，并通过提供保存目录重新加载。
- 通过提供本地目录作为
pretrained_model_name_or_path加载模型，并在目录中找到名为config.json的配置 JSON 文件。
-
cache_dir(Union[str, os.PathLike], optional) — 如果不应使用标准缓存，则应将下载的预训练模型配置缓存在其中的目录路径。 -
from_pt(bool, optional, 默认为False) — 从 PyTorch 检查点保存文件加载模型权重（请参阅pretrained_model_name_or_path参数的文档字符串）。 -
ignore_mismatched_sizes(bool, optional, 默认为False) — 如果检查点中的某些权重与模型的权重大小不同，是否引发错误（例如，如果您从具有 3 个标签的检查点实例化具有 10 个标签的模型）。 -
force_download(bool, optional, 默认为False) — 是否强制（重新）下载模型权重和配置文件，覆盖缓存版本（如果存在）。 -
resume_download(bool, optional, 默认为False) — 是否删除接收不完整的文件。如果存在这样的文件，将尝试恢复下载。 -
proxies(Dict[str, str], optional) — 一个按协议或端点使用的代理服务器字典，例如，{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}。代理在每个请求上使用。 -
local_files_only(bool,optional, 默认为False) — 是否仅查看本地文件（即，不尝试下载模型）。 -
token(str或bool, 可选) — 用作远程文件的 HTTP bearer 授权的令牌。如果为True，或未指定，将使用运行huggingface-cli login时生成的令牌 (存储在~/.huggingface中)。 -
revision(str, 可选, 默认为"main") — 要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID，因为我们在 huggingface.co 上使用基于 git 的系统来存储模型和其他工件，所以revision可以是 git 允许的任何标识符。
从预训练模型配置实例化一个预训练的 flax 模型。
警告 来自 XXX 的权重未从预训练模型初始化 意味着 XXX 的权重不是与模型的其余部分一起预训练的。您需要使用下游微调任务来训练这些权重。
警告 来自 XXX 的权重在 YYY 中未使用 意味着层 XXX 在 YYY 中未被使用，因此这些权重被丢弃。
示例：
>>> from transformers import BertConfig, FlaxBertModel
>>> # Download model and configuration from huggingface.co and cache.
>>> model = FlaxBertModel.from_pretrained("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 ) → export const metadata = 'undefined';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() 类方法重新加载。
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("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("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。
将浮点 params 转换为 jax.numpy.float16。这将返回一个新的 params 树，不会直接在原地转换 params。
此方法可在 GPU 上使用，显式将模型参数转换为 float16 精度，以进行完全的半精度训练或以 float16 保存权重以用于推理，以节省内存并提高速度。
示例：
>>> from transformers import FlaxBertModel
>>> # load model
>>> model = FlaxBertModel.from_pretrained("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("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。
将浮点 params 转换为 jax.numpy.float32。此方法可用于显式将模型参数转换为 fp32 精度。这将返回一个新的 params 树，不会直接在原地转换 params。
示例：
>>> from transformers import FlaxBertModel
>>> # Download model and configuration from huggingface.co
>>> model = FlaxBertModel.from_pretrained("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
( )一个包含将模型或分词器推送到 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], 可选) — 要推送到中心的标签列表。
将{object_files}上传到🤗模型中心。
示例：
from transformers import {object_class}
{object} = {object_class}.from_pretrained("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 ) → export const metadata = 'undefined';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是一个包含缺失键的字符串列表 -
unexpected_keys是一个包含意外键的字符串列表
这与torch.nn.Module.load_state_dict相同，但适用于分片检查点。
这种加载效率很高：每个检查点分片都会逐个在 RAM 中加载，加载到模型后会被删除。
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("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
( )一个包含将模型或分词器推送到 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], 可选) — 要推送到中心的标签列表。
将{object_files}上传到🤗模型中心。
示例：
from transformers import {object_class}
{object} = {object_class}.from_pretrained("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 ) → export const metadata = 'undefined';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是一个包含缺失键的字符串列表 -
unexpected_keys是一个包含意外键的字符串列表
这与torch.nn.Module.load_state_dict相同，但适用于分片检查点。
这种加载效率很高：每个检查点分片都会逐个在 RAM 中加载，加载到模型后会被删除。
本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2024-06-23，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录
相关产品与服务
对象存储
对象存储（Cloud Object Storage，COS）是由腾讯云推出的无目录层次结构、无数据格式限制，可容纳海量数据且支持 HTTP/HTTPS 协议访问的分布式存储服务。腾讯云 COS 的存储桶空间无容量上限，无需分区管理，适用于 CDN 数据分发、数据万象处理或大数据计算与分析的数据湖等多种场景。