Question

1. 基类 PreTrainedModel, TFPreTrainedModel, FlaxPreTrainedModel 实现了加载/保存模型的通用方法。此外，PreTrainedModel 和 TFPreTrainedModel 还实现了一些通用方法从而：

   • 当添加新 token 到词表时，resize 模型的 input token embedding matrix （注意，是增加 embedding vector，而不是调整 embedding 维度）。
   • 裁剪模型的 attention head 。

   其它的一些通用方法定义在 ModuleUtilsMixin（用于 PyTorch 模型）、或 TFModuleUtilsMixin （用于 TensorFlow 模型）。也有一些用于文本生成的方法定义在 GenerationMixin（用于 PyTorch 模型）、TFGenerationMixin（用于 TensorFlow 模型）、或 FlaxGenerationMixin（用于 Flax/JAX 模型）。

3.1 API

1. class transformers.PreTrainedModel(config: PretrainedConfig, *inputs, **kwargs)：所有模型的基类。

   PreTrainedModel 负责存储模型的配置，并处理加载、下载、以及保存模型的方法，以及所有模型都有的一些方法（如 resize input embedding、裁剪 the self-attention 中的 head）。

   参数：

   • config：一个 PretrainedConfig 对象，指定模型的配置。
   • inputs：一个位置参数，指定模型的 input 。

   类属性（由派生类重写）：

   • config_class：一个 PretrainedConfig 对象，它是 PretrainedConfig 的子类，指定模型的配置类。

   • load_tf_weights：一个可调用对象，用于在一个 PyTorch 模型中加载一个 TensorFlow checkpoint 。这个可调用对象的参数为：

     • model：一个 PretrainedModel对象，指定用于加载TensorFlow checkpoint的模型实例。
     • config：一个 PreTrainedConfig 对象，指定模型相关的配置对象。
     • path：一个字符串，指定 TensorFlow checkpoint 的路径。

   • base_model_prefix：一个字符串，表示在与 base model 架构相同的派生类（这个派生类在 base model 之上添加模块）中与 base model 相关的属性。

   • is_parallelizable：一个布尔值，表示模型是否支持模型并行。

   • main_input_name：一个字符串，表示模型的 main input 的名字（通常而言，对于 NLP 模型是 "input_ids"、对于视觉模型而言是 "pixel_values"、对于语音模型而言是 "input_values" ）。

   方法：

   • push_to_hub()：将模型文件上传到 Model Hub ，同时同步到 repo_path_or_name 对应的 local clone 。

     
     xxxxxxxxxx
     push_to_hub(repo_id: str, use_temp_dir: typing.Optional[bool] = Nonec, ommit_message: typing.Optional[str] = None, private: typing.Optional[bool] = None, use_auth_token: typing.Union[bool, str, NoneType] = None, max_shard_size: typing.Union[int, str, NoneType] = '10GB', create_pr: bool = False, **deprecated_kwargs 
     )

     参数：参考 PreTrainedTokenizerBase.push_to_hub() 方法。

   • from_pretrained( pretrained_model_name_or_path: typing.Union[str, os.PathLike, NoneType], *model_args, **kwargs)：从一个pre-trained model configuration 中实例化一个 pretrained pytorch model 。

     注意：

     • 该模型通过默认使用 model.eval() 来设置为 evaluation mode （Dropout 模块被停用）。要训练这个模型，你应该先用model.training() 将其设置回 training mode。
     • 警告 Weights from XXX not initialized from pretrained model 意味着 XXX 的权重不与模型的其他部分一起进行预训练。这取决于你用下游的微调任务来训练这些权重。
     • 警告 Weights from XXX not used in YYY 意味着 layer XXX 没有被 YYY 使用，因此这些权重被丢弃。

     参数：

     • pretrained_model_name_or_path：一个字符串或 os.PathLike 对象，可以为：

       • 一个字符串，指定位于 huggingface.co 的 model repo 中的预训练模型的 model id ，如 bert-base-uncased、dbmdz/bert-base-german-cased 。

       • 一个目录的路径，该目录包含模型权重（由 save_pretrained() 保存）。

       • 一个指向 tensorflow index checkpoint file 的路径或 url 。此时，from_tf 参数应该设为 True，并且 config 参数应该被提供一个配置对象。

         这种加载路径比使用提供的转换脚本在 PyTorch 模型中转换 TensorFlow checkpoint 并在之后加载 PyTorch 模型要慢。

       • 一个指向 flax checkpoint file（为 .msgpack 格式） 的路径或 url 。此时，from_flax 参数应该设为 True。

       • None，如果你同事提供了配置文件、以及 state 字典。即，以 config 和 state_dict 关键字参数来传入。

     • model_args：位置参数，它们将被传给底层模型的 __init__ 方法。

     • confg：一个 PretrainedConfig 对象、字符串、或 PathLike 对象，指定用于模型的配置（而不是自动加载配置）。

       如果是字符串或 PathLike 对象，则调用 PretrainedConfig.from_pretrained() 方法。

       对于以下情形，配置将被自动加载：

       • 模型是由 library 提供，即通过预训练模型的 model id 来加载模型。
       • 模型通过 save_pretrained() 方法保存，同时从被保存的目录中再次加载模型。
       • 模型通过以下方式被加载：pretrained_model_name_or_path 是一个本地路径、且该本地路径中找到一个叫做 config.json 的 configuration JSON file 。

     • state_dict：一个 Dict[str, torch.Tensor] 字典，直接指定模型的 state 而不是从保存的权重文件中加载。

       如果你想从一个预训练的配置中创建一个模型，但加载你自己的权重，可以使用这个方式。

     • cache_dir/force_download/resume_download/proxies/local_files_only/use_auth_token/revision：这些参数参考 PreTrainedTokenizerBase.from_pretrained() 。

     • from_tf：一个布尔值，指定是否从 TensorFlow checkpoint save file 中加载模型权重。

     • from_flax：一个布尔值，指定是否从 Flax checkpoint save file 中加载模型权重。

     • ignore_mismatched_sizes：一个布尔值，指定如果 checkpoint 的某些权重与模型的权重尺寸不一致，是否会引发错误。

     • output_loading_info：一个布尔值，指定是否同时返回一个包含 missing keys 、unexpected keys 和 error messages 的字典。

     用于大模型推断的参数：

     • low_cpu_mem_usage：一个布尔值，指定是否试图在加载模型时不使用超过 1 倍的模型大小的 CPU 内存（包括峰值内存）。通常加载模型需要 2 倍于模型的内存大小，一倍用于随机初始化模型（target）、一倍用于预训练好的权重（source）。

       这是一个实验性的功能，可以随时改变。它的工作方式如下：

       • 保存 state_dict 的键。
       • 在创建模型之前放弃 state_dict ，因为后者需要1 倍模型大小的 CPU 内存。
       • 在模型被实例化后，将所有 params/buffers 切换到 meda device （即，empty weights），这些 params/buffers 将要被来自于 state_dict 中的值所替代。
       • 第二次加载 state_dict 。
       • 将来自 state_dict 中的值来替代 params/buffers 。

       目前，它无法处理 deepspeed ZeRO state3，并且忽略了 loading 错误。

     • torch_dtype：一个字符串或 torch.dtype，覆盖默认的 torch.dtype 并在此 dtype 下加载模型。如果传入 "auto"，则 dtype 将自动从模型的权重中推导。

       Pytorch 模型默认使用 torch.float32 的权重类型，如果你需要加载一个 fp16 类型的模型，那么需要再 from_pretrained() 方法中指定 torch_dtype 。

       或者也可以在创建模型的时候，通过 config 来告诉模型是什么类型的权重：

       
       xxxxxxxxxx
       config = T5Config.from_pretrained("t5")
       model = AutoModel.from_config(config)

     • device_map：一个字符串，或 Dict[str, Union[int, str, torch.device]] 字典，指定每个子模块对应的设备。不需要细化到每个参数/缓冲区名称，一旦指定一个模块的名字，它的每个子模块将被发送到同一个设备。

       如果模型无法完全容纳在内存中，你可以直接将模型放在不同的设备上（目前仅适用于推断）。要让 Accelerate 自动计算出最优的 device_map ，请设置 device_map="auto" 。此时，Accelerate 将决定模型的每一层放置在哪里，从而最大限度地利用你最快的设备（GPU），并将其余部分卸载到 CPU 上、甚至是磁盘上（如果你没有足够的 GPU 内存或 CPU 内存）。即使模型被分割到几个设备上，它也会像你通常期望的那样运行。

       当你传入一个 device_map （如，"auto"）时，low_cpu_mem_usage 自动被设置为 True。

       你可以通过查看模型的 hf_device_map 属性来检查模型是如何被分片到设备上的：

       
       xxxxxxxxxx
       from transformers import AutoModelForSeq2SeqLM
       t0pp = AutoModelForSeq2SeqLM.from_pretrained("bigscience/T0pp", device_map="auto")
       print(t0pp.hf_device_map)
       # {'shared': 0,
       #  'decoder.embed_tokens': 0,
       #  ...
       #  'decoder.dropout': 'cpu',
       #  'lm_head': 'cpu'}

       或者你也可以直接人工指定：

       
       xxxxxxxxxx
       device_map = {"shared": 0, "encoder": 0, "decoder": 1, "lm_head": 1}

     • max_memory：一个字典，指定每个设备的最大内存。如果未设定，则默认为每个 GPU 的可用最大内存、以及 CPU 的可用内存。

     • offload_folder：一个字符串或 os.PathLike 对象。如果 device_map 包含任何的值 "disk"，那么这个目录就是我们用于 offload weights 的。

     • offload_state_dict：一个布尔值，如果为 True 那么将暂时把 CPU state dict 卸载 offload 到磁盘上，从而避免 CPU 内存耗尽。当有一些 disk offload 时，默认为 True 。

     • load_in_8bit：一个布尔值，如果为 True，则把加载的模型转换为 mixed-8bit quantized model 。

     • load_in_8bit_threshold：一个浮点数，与 load_in_8bit 一起工作。

     • load_in_8bit_skip_modules：一个字符串列表，指定哪些模块不希望被转换为 8 bit 。

     • subfolder：一个字符串，如果相关的文件位于 huggingface.co 上的模型 repo 的一个子文件夹内，你可以在这里指定文件夹的名称。

     • kwargs：关键字参数，可以用于更新配置对象（在配置对象被加载完成之后）、初始化模型（如 output_attentions=True）。

   • get_input_embeddings() -> nn.Module：返回模型的 input embedding （它将词表映射到 embedding matrix）。

   • get_memory_footprint(return_buffers = True)：返回模型的内存占用，单位是字节。这对于 benchmark 当前模型的内存占用、以及设计某些测试很有用。

   • get_output_embeddings() -> nn.Module：返回模型的 output embedding （它将词表映射到 embedding matrix）。

   • gradient_checkpointing_disable()：停用当前模型的 gradient checkpointing （也被叫做 activation checkpointing 或 checkpoint activations ）。

   • gradient_checkpointing_enable()：启用当前模型的 gradient checkpointing 。

   • init_weights()：如果需要的话，对权重进行裁剪和初始化。

   • post_init()：在每个 Transformer 模型初始化结束时执行的方法（如权重初始化）。

   • prune_heads(heads_to_prune: typing.Dict[int, typing.List[int]] )：裁剪 base model 的 head 。

     参考 PretrainedConfig 的初始化方法。

   • register_for_auto_class( auto_class = 'AutoModel')：将当前 class 注册到给定的 auto class 。

     参考 PretrainedConfig.register_for_auto_class() 方法。

   • resize_token_embeddings(new_num_tokens: typing.Optional[int] = None ) -> torch.nn.Embedding：如果 new_num_tokens != config.vocab_size ，那么 resize 模型的 input token embeddings matrix 。

     参数：new_num_tokens：一个整数，指定新的 token 总数。如果总数增加，那么添加新的被初始化的 embedding vector；如果总数减少，那么从 embedding matrix 尾部移除 embedding vector 。

     如果模型有一个 tie_weights() 方法时，要小心 tying weights embedding 。

   • save_pretrained()：将模型和它的配置文件保存到目录中，以便后续可以使用 from_pretrained() 方法重新加载该模型。

     
     xxxxxxxxxx
     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 0x7fe13d86c310>, push_to_hub: bool = Fals, emax_shard_size: typing.Union[int, str] = '10GB', safe_serialization: bool = False, **kwargs )

     参数：

     • save_directory/push_to_hub/max_shard_size：参考 PreTrainedTokenizerBase.save_pretrained() 方法。
     • is_main_process：一个布尔值，指定调用该方法的进程是否是主进程。在像 TPU 这样的分布式训练中很有用，需要在所有进程上调用该方法。在这种情况下，仅在主进程上设置 is_main_process=True 从而避免争用。
     • state_dict ：torch.Tensor 的嵌套字典，指定要保存的模型的 state dictionary 。默认为 self.state_dict() ，但可以用来只保存模型的部分内容，或者在恢复模型的 state dictionary 时需要采取特殊的预防措施（比如使用模型并行时）。
     • save_function：一个可调用对象，它用于保存 state dictionary 。在如下场景很有用： TPU 这样的分布式训练，且需要用另一个方法来代替 torch.save 时。
     • safe_serialization：一个布尔值，指定是否使用 safetensors 或传统的 PyTorch 方式（即，pickle）保存模型。
     • kwargs：关键字参数，传递给 push_to_hub() 方法。

   • set_input_embeddings(value: Module )：设置模型的 input embedding 。

     参数：value：一个 nn.Module，它将词表映射到 embedding matrix 。

   • tie_weights()：将 input embedding 和 output embedding 进行权重绑定（即，权重共享）。

     如果在配置中设置了 torchscript flag，那么无法处理权重共享，此时我们将拷贝权重。

2. class transformers.modeling_utils.ModuleUtilsMixin()：用于 torch.nn.Modules 的一些工具方法，它被作用 mixin 。

   方法：

   • add_memory_hooks()：在每个子模块的前向传播的 before/after 添加一个 memory hook，从而记录内存消耗的增加。

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

   • estimate_tokens(input_dict: typing.Dict[str, typing.Union[torch.Tensor, typing.Any]]) -> int：一个 helper 方法，用于从 model input 中估计总的 token 数量。

     参数：input_dict：一个字典，给出 model inputs 。

   • floating_point_ops(batch_size:int, sequence_length:int, exclude_embeddings: bool = True ) -> int：获取该 transformer 模型对一个 batch 的前向传播和反向传播的浮点运算数量（non-embedding）。

     参数：

     • batch_size：一个整数，指定 batch size 。
     • sequence_length：一个整数，指定 batch 中每个样本的 token 数量。
     • exclude_embeddings：一个布尔值，指定是否考虑 embedding 操作和 softmax 操作的浮点数运算。

     默认的近似值忽略了对 token 数量的二次方依赖（如果 12 * d_model << sequence_length 则有效）。对于有参数共享的 transformer（如 ALBERT 或 Universal Transformer），或者对长序列进行长距离建模时，应该重写该方法。

   • get_extended_attention_mask(attention_mask: Tensor, input_shape: typing.Tuple[int], device: <property object at 0x7fe13accc720> = None, dtype: torch.float32 = None ) ：获得 broadcastable attention 和 causal mask ，使得未来的和 masked 的 token 被忽略。

     参数：

     • attention_mask：一个张量，指定 Mask，其中元素 1 代表 un-masked、0 代表 masked。
     • input_shape：一个元组（类型为整数），指定模型的 input 的形状。

   • get_head_mask( head_mask: typing.Optional[torch.Tensor], num_hidden_layers: int, is_attention_chunked: bool = False)：准备 head mask 。

     参数：

     • head_mask：一个形状为 [num_heads] 或 [num_hidden_layers x num_heads] 的张量，指定我们要保留哪些 head（1 表示保留，0 表示放弃）。
     • num_hidden_layers：一个整数，指定模型的隐层的数量。
     • is_attention_chunked：一个布尔值，指定 attentions score 是否按 chunk 来计算的。

   • invert_attention_mask( encoder_attention_mask: Tensor ) -> torch.Tensor：翻转一个 attention mask（即，翻转 0 和 1）。

   • num_parameters(only_trainable: bool = False， exclude_embeddings: bool = False ) -> int：返回模型中的所有参数数量。

     参数：

     • only_trainable：一个布尔值，指定是否进考虑可训练的参数。
     • exclude_embeddings：一个布尔值，指定是否排除 embedding 参数。

   • reset_memory_hooks_state()：清零每个模块的 mem_rss_diff 属性。

3. class transformers.TFPreTrainedModel(*args, **kwargs) ：所有 TF 模型的基类。

   参数：参考 PreTrainedModel 。

   类别属性：参考 PreTrainedModel 。

   方法：

   • push_to_hub()：参考 PreTrainedModel.push_to_hub() 。

     
     xxxxxxxxxx
     push_to_hub(repo_id: str, use_temp_dir: typing.Optional[bool] = None, commit_message: typing.Optional[str] = None, private: typing.Optional[bool] = None, use_auth_token: typing.Union[bool, str, NoneType] = None, max_shard_size: typing.Union[int, str, NoneType] = '10GB', **model_card_kwargs)

   • compile()：编译模型。

     
     xxxxxxxxxx
     compile(optimizer = 'rmsprop', loss = 'passthrough', metrics = None, loss_weights = None, weighted_metrics = None, run_eagerly = None, steps_per_execution = None, **kwargs )

   • create_model_card()：创建一个 model card 。

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

   • eager_serving(inputs)：用于 model serving 的方法。打算不与 tf.function decorator 一起编译，以便我们以后可以用它来生成多个 signature。

     参数：inputs ：一个字典 Dict[str, tf.Tensor]，用于 saved model 的输入。

   • from_pretrained(pretrained_model_name_or_path, *model_args, **kwargs )：参考 PreTrainedModel.from_pretrained() 。

   • get_bias() -> tf.Variable：关联到 LM head 的、关于 bias 的字典，key 为 bias 属性的名字。

   • get_input_embeddings() -> tf.Variable：参考 PreTrainedModel.get_input_embeddings() 。

   • get_lm_head() -> tf.keras.layers.Layer：获取 LM Head Layer （如果模型只有一个 head layer）或者返回 None 。

     对于拥有 lm head 的所有模型，必须重写该方法。

   • get_output_embeddings()：参考 PreTrainedModel.get_output_embeddings() 。

   • get_output_layer_with_bias() -> tf.keras.layers.Layer：获取 output layer 。

   • get_prefix_bias_name() -> str：获取 bias 的被拼接的 _prefix name 。

   • load_repo_checkpoint(repo_path_or_name) -> dict：从一个 repo 中加载一个 saved checkpoint（包含模型权重和 optimizer state）。

     返回一个字典，该字典包含 extra metadata 信息，例如当前的 epoch 计数。

   • prepare_tf_dataset()：将 HuggingFace Dataset 封装为一个具有 collation 和 batching 的 tf.data.Dataset 。

     
     xxxxxxxxxx
     prepare_tf_dataset(dataset: datasets.Dataset, batch_size: int = 8, shuffle: bool = True, tokenizer: typing.Optional[ForwardRef('PreTrainedTokenizerBase')] = None, collate_fn: typing.Optional[typing.Callable] = None, collate_fn_args: typing.Union[typing.Dict[str, typing.Any], NoneType] = None, drop_remainder: typing.Optional[bool] = None, prefetch: bool = True) -> Dataset

     该方法用于创建一个 ready-to-use 的 dataset，从而可以直接传递给 Keras 的方法（如 fit()）而无需进一步修改。

     如果数据集的列与模型的 input names 不匹配，那么不匹配的列将从数据集中删除。如果你想指定返回的列名，而不是使用与该模型相匹配的名字，我们建议使用 Dataset.to_tf_dataset() 代替。

   • prune_heads(heads_to_prune )：参考 PreTrainedModel.prune_heads() 方法。

   • register_for_auto_class(auto_class = 'TFAutoModel' )：参考 PreTrainedModel.register_for_auto_class() 方法。

   • resize_token_embeddings(new_num_tokens: typing.Optional[int] = None ) -> tf.Variable or tf.keras.layers.Embedding：参考 PreTrainedModel.resize_token_embeddings() 方法。

   • save_pretrained()：将模型和它的配置文件保存到目录中，以便后续可以使用 from_pretrained() 方法重新加载该模型。

     
     xxxxxxxxxx
     save_pretrained(save_directory, saved_model = False, version = 1, push_to_hub = False, signatures = None, max_shard_size: typing.Union[int, str] = '10GB', create_pr: bool = False, safe_serialization: bool = False, **kwargs )

     参数：

     • save_directory/push_to_hub/max_shard_size/safe_serialization/kwargs：参考 PreTrainedModel.save_pretrained() 方法。
     • saved_model：一个布尔值，指定模型是否也必须以 saved model 格式保存。
     • version：一个整数，指定 saved model 的版本。
     • signatures：一个字典或 tf.function，指定用于 serving 的 model's signature。这将被传递给 model.save() 的 signatures 参数。
     • create_pr：一个布尔值，指定是否创建一个 PR 还是直接 commit 。

   • serving(inputs: Dict[str, tf.Tensor])：用于 model serving 的方法。

     参数：inputs：一个从字符串到 tf.Tensor 的字典，给出 saved model 的 input 。

   • serving_output(output: TFBaseModelOutput)：准备 saved model 的 output。每个模型必须实现该方法。

     参数：output：由模型返回的 output 。

   • set_bias(value: Dict[tf.Variable])：设置 LM head 中的所有 bias 。

   • set_input_embeddings(value)：参考 PreTrainedModel.set_input_embeddings() 方法。

   • set_output_embeddings(value)：设置模型的 output embedding 。

   • test_step(data)：对 Keras 默认的 train_step 的修改，为我们的模型正确处理了我们 outputs 与 labels 的匹配，并支持直接在 loss output head 上进行训练。此外，它确保 input keys 在适当的地方被复制到 labels 上。当使用 dummy loss 时，它也会将 label keys 复制到 input dict 中，以确保它们在前向传播过程中对模型可用。

   • train_step(data)：参考 test_step() 。

4. class transformers.modeling_tf_utils.TFModelUtilsMixin()：用于 tf.keras.Model 的一些工具方法，它被作用 mixin 。

   方法：

   • num_parameters(only_trainable: bool = False) -> int：参考 ModuleUtilsMixin.num_parameters() 。

5. class transformers.FlaxPreTrainedModel：所有 Flax 模型的基类。

   
   xxxxxxxxxx
   class transformers.FlaxPreTrainedModel(config: PretrainedConfig,
           module: Moduleinput_shape: typing.Tuple = (1, 1),
           seed: int = 0,
           dtype: dtype = <class 'jax.numpy.float32'>,
           _do_init: bool = True )

   参数：参考 PreTrainedModel 。

   类别属性：参考 PreTrainedModel 。

   方法：

   • load_flax_sharded_weights(shard_files: List[str]) -> Dict：加载 flax 模型的权重。这种加载是高效的：每个 checkpoint shard 在 RAM 中被逐一加载，并在被加载到模型中之后被删除。

     返回模型参数的嵌套字典，格式为 {'model': {'params': {'...'}}} 。

   • to_bf16(params: typing.Union[typing.Dict, flax.core.frozen_dict.FrozenDict], mask: typing.Any = None) ：将浮点参数强制类型转换为 jax.numpy.bfloat16 。它返回一个新的 prams tree 而不是原地转换。

     参数：

     • params：一个字典或 FrozenDict ，给出了模型参数的 PyTree 。
     • mask：与 params 结构相同的 PyTree，叶子节点为布尔值，表示对应的 params 是否需要强制类型转换。

     该方法可以在 TPU 上使用，从而模型参数显式转换为 bfloat16 精度。

   • to_fp16(params: typing.Union[typing.Dict, flax.core.frozen_dict.FrozenDict], mask: typing.Any = None)：将浮点参数强制类型转换为 jax.numpy.float16 。参考 to_bf16。

     该方法可以在 GPU 上使用，从而模型参数显式转换为 float16 精度。

   • to_fp32(params: typing.Union[typing.Dict, flax.core.frozen_dict.FrozenDict], mask: typing.Any = None)：将浮点参数强制类型转换为 jax.numpy.float32 。参考 to_bf16。

   • 以下方法参考 TFPreTrainedModel：

     
     xxxxxxxxxx
     push_to_hub(repo_id: str, use_temp_dir: typing.Optional[bool] = None, commit_message: typing.Optional[str] = None, private: typing.Optional[bool] = None, use_auth_token: typing.Union[bool, str, NoneType] = None, max_shard_size: typing.Union[int, str, NoneType] = '10GB', create_pr: bool = False, **deprecated_kwargs) 
     from_pretrained(pretrained_model_name_or_path: typing.Union[str, os.PathLike], dtype: dtype = <class 'jax.numpy.float32'>, *model_args, **kwargs)
     register_for_auto_class(auto_class = 'FlaxAutoModel')
     save_pretrained(save_directory: typing.Union[str, os.PathLike], params = None, push_to_hub = False, max_shard_size = '10GB', **kwargs )

6. class transformers.utils.PushToHubMixin()：一个 mixin，它包含一些函数用于 push 一个模型或 tokenizer 到 hub 上。

   方法：

   • push_to_hub()：参考 PreTrainedModel.push_to_hub() 。

     
     xxxxxxxxxx
     push_to_hub(repo_id: str, use_temp_dir: typing.Optional[bool] = None, commit_message: typing.Optional[str] = None, private: typing.Optional[bool] = None, use_auth_token: typing.Union[bool, str, NoneType] = None, max_shard_size: typing.Union[int, str, NoneType] = '10GB', create_pr: bool = False, **deprecated_kwargs)

7. transformers.modeling_utils.load_sharded_checkpoint(model: torch.nn.Module, folder: str or os.PathLike, strict = True) -> NamedTuple：与 torch.nn.Module.load_state_dict() 相同，但是该函数用于 sharded checkpoint 。

   这种加载是高效的：每个 checkpoint shard 在 RAM 中被逐一加载，并在被加载到模型中之后被删除。

   参数：

   • model：一个 Module 对象，指定哪个模型需要加载 checkpoint。
   • folder：一个字符串或 os.PathLike对象，指定哪个目录包含 checkpoint。
   • strict：一个布尔值，指定是否严格加载（即，model state dict 和 sharded checkpoint 严格匹配）。

   返回一个命名元组，包含两个字段：

   • missing_keys：包含 missing key 的列表。
   • unexpected_keys：包含 unexpected key 的列表。