# Modelos

A classe base [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel) implementa os métodos comuns para carregar/salvar um modelo a partir de um arquivo ou diretório local, ou a partir de uma configuração de modelo pré-treinado fornecida pela biblioteca (baixada do Hub da HuggingFace).

[PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel) também implementa alguns métodos comuns a todos os modelos para:

- redimensionar os embeddings de tokens de entrada quando novos tokens são adicionados ao vocabulário

Os outros métodos comuns a cada modelo são definidos em [ModuleUtilsMixin](/docs/transformers/main/pt/main_classes/model#transformers.modeling_utils.ModuleUtilsMixin) e [GenerationMixin](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin).

## PreTrainedModel[[transformers.PreTrainedModel]]

#### transformers.PreTrainedModel[[transformers.PreTrainedModel]]

```python
transformers.PreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1068)

Classe base para todos os modelos.

[PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel) cuida do armazenamento da configuração dos modelos e gerencia os métodos para carregar, baixar e salvar modelos, além de alguns métodos comuns a todos os modelos:

- redimensionar os embeddings de entrada

Atributos de classe (substituídos por classes derivadas):

- **config_class** ([PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig)) -- Uma subclasse de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) a ser usada como classe de configuração para esta arquitetura de modelo.
- **base_model_prefix** (`str`) -- Uma string que indica o atributo associado ao modelo base em classes derivadas da mesma arquitetura que adicionam módulos sobre o modelo base.
- **main_input_name** (`str`) -- O nome da entrada principal do modelo (frequentemente `input_ids` para modelos de NLP, `pixel_values` para modelos de visão e `input_values` para modelos de fala).
- **can_record_outputs** (dict):

#### push_to_hub[[transformers.PreTrainedModel.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L822)

**Parâmetros:**

repo_id (`str`) : O nome do repositório para o qual você deseja enviar seu modelo. Deve conter o nome da sua organização ao enviar para uma organização específica.

commit_message (`str`, *opcional*) : Mensagem a ser commitada durante o push. O valor padrão será `"Upload model"`.

commit_description (`str`, *opcional*) : A descrição do commit que será criado

private (`bool`, *opcional*) : Se deve tornar o repositório privado. Se `None` (padrão), o repositório será público, a menos que o padrão da organização seja privado. Este valor é ignorado se o repositório já existir.

token (`bool` ou `str`, *opcional*) : O token a ser usado como autorização bearer HTTP para arquivos remotos. Se `True` (padrão), usará o token gerado ao executar `hf auth login` (armazenado em `~/.huggingface`).

revision (`str`, *opcional*) : Branch para a qual os arquivos enviados serão enviados.

create_pr (`bool`, *opcional*, padrão `False`) : Se deve ou não criar um PR com os arquivos enviados ou fazer o commit diretamente.

max_shard_size (`int` ou `str`, *opcional*, padrão `"50GB"`) : Aplicável apenas a modelos. O tamanho máximo de um checkpoint antes de ser fragmentado. Os fragmentos do checkpoint terão, então, cada um um tamanho menor que esse valor. Se expresso como string, deve conter dígitos seguidos de uma unidade (como `"5MB"`).

tags (`list[str]`, *opcional*) : Lista de tags para enviar no Hub.

Envie o arquivo do modelo para o 🤗 Model Hub.

Exemplos:

```python
from transformers import AutoModel

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

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

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

#### activation_checkpointing_disable[[transformers.PreTrainedModel.activation_checkpointing_disable]]

```python
activation_checkpointing_disable()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3249)

Desativa o checkpointing de ativação para o modelo atual.

#### activation_checkpointing_enable[[transformers.PreTrainedModel.activation_checkpointing_enable]]

```python
activation_checkpointing_enable(activation_checkpointing_kwargs = None, every_n_layers: int = 1, offload: bool = False)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3110)

**Parâmetros:**

every_n_layers (`int`, *opcional*, padrão 1) : Cria um checkpoint apenas a cada `every_n_layers`-ésima camada do decoder, mantendo as ativações das demais. `1` cria um checkpoint em cada camada, o que é o comportamento usual de tudo ou nada. Valores maiores trocam memória por velocidade, o que vale a pena sempre que a memória liberada pelo checkpoint completo ficar sem uso.

offload (`bool`, *opcional*, padrão `False`) : Mantém as ativações salvas para o recompute em memória de host fixada (pinned host memory) em vez de no acelerador. Isso libera `layers x sequence x hidden` bytes de memória de dispositivo, o que predomina em comprimentos de sequência longos, e custa uma cópia de dispositivo para host no forward e uma cópia de host para dispositivo no backward. Ambas as cópias são executadas no stream de computação, tornando a etapa mais lenta.

activation_checkpointing_kwargs (dict, *opcional*) : Argumentos de palavra-chave adicionais passados para a função `torch.utils.checkpoint.checkpoint`.

Ativa o checkpointing de ativação para o modelo atual.

Passamos o método `__call__` dos módulos em vez de `forward`, pois `__call__` anexa todos os hooks do módulo. https://discuss.pytorch.org/t/any-different-between-model-input-and-model-forward-input/3690/2

#### add_model_tags[[transformers.PreTrainedModel.add_model_tags]]

```python
add_model_tags(tags: list[str] | str)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1360)

**Parâmetros:**

tags (`Union[list[str], str]`) : As tags desejadas para injetar no modelo

Adiciona tags personalizadas ao modelo que será enviado ao Hugging Face Hub. Não substituirá as tags existentes no modelo.

Exemplos:

```python
from transformers import AutoModel

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

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

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

#### can_generate[[transformers.PreTrainedModel.can_generate]]

```python
can_generate()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1474)

**Retorna:** `bool`

Se este modelo pode gerar sequências com `.generate()`.

Indica se este modelo pode gerar sequências com `.generate()`, a partir da `GenerationMixin` ou de uma com interface semelhante.

Por baixo dos panos, nas classes em que esta função retorna True, algumas alterações específicas de geração são acionadas: por exemplo, a instância do modelo terá um atributo `generation_config` preenchido.

#### cuda[[transformers.PreTrainedModel.cuda]]

```python
cuda(*args, **kwargs)
```

Um valor simulado para um caminho pontilhado (por exemplo, `torch.float32`): as cadeias de acesso a atributos e as chamadas se comportam como decoradores de passagem, o `repr` é o caminho pontilhado, e o uso como classe base substitui uma base de `type` simples (PEP 560 `__mro_entries__`), de modo que as subclasses reais mantêm um metaclass normal e o `inspect.signature` lê o `__init__` real delas, em vez do de um mock.

#### dequantize[[transformers.PreTrainedModel.dequantize]]

```python
dequantize(dtype = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1342)

Potencialmente desquantize o modelo, caso ele tenha sido quantizado por um método de quantização que suporte desquantização.

#### disable_input_require_grads[[transformers.PreTrainedModel.disable_input_require_grads]]

```python
disable_input_require_grads()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2181)

Remove o `_require_grads_hook`.

#### enable_input_require_grads[[transformers.PreTrainedModel.enable_input_require_grads]]

```python
enable_input_require_grads()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2137)

Ativa os gradientes para os embeddings de entrada. Isso é útil para ajustar os pesos do adaptador mantendo os pesos do modelo fixos.

#### from_pretrained[[transformers.PreTrainedModel.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike | None, *model_args, config: transformers.configuration_utils.PreTrainedConfig | str | os.PathLike | None = None, cache_dir: str | os.PathLike | None = None, ignore_mismatched_sizes: bool = False, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', use_safetensors: bool | None = None, weights_only: bool = True, fusion_config: dict[str, bool | dict[str, typing.Any]] | None = None, disable_mmap: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3892)

**Parâmetros:**

pretrained_model_name_or_path (`str` ou `os.PathLike`, *opcional*) : Pode ser:  - Uma string, o *model id* de um modelo pré-treinado hospedado em um repositório de modelos no huggingface.co. - Um caminho para um *diretório* contendo pesos de modelo salvos usando [save_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.save_pretrained), por exemplo, `./my_model_directory/`. Diretórios salvos com `save_pretrained(..., distributed_checkpoint=True)` são detectados e carregados com distributed checkpointing (DCP), preservando a malha e os placements atuais do modelo. Isso requer `torch>=2.7` e carrega de forma estrita: cada chave do modelo deve estar presente no checkpoint. - `None` se você estiver fornecendo tanto a configuração quanto o dicionário de estado (respectivamente, com os argumentos de palavra-chave `config` e `state_dict`).

model_args (sequência de argumentos posicionais, *opcional*) : Todos os argumentos posicionais restantes serão passados para o método `__init__` do modelo subjacente.

config (`Union[PreTrainedConfig, str, os.PathLike]`, *opcional*) : Pode ser:  - uma instância de uma classe derivada de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig), - uma string ou caminho válido como entrada para [from_pretrained()](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained).  Configuração do modelo a ser usada no lugar de uma configuração carregada automaticamente. A configuração pode ser carregada automaticamente quando:  - O modelo é um modelo fornecido pela biblioteca (carregado com a string de *model id* de um modelo pré-treinado). - O modelo foi salvo usando [save_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.save_pretrained) e é recarregado fornecendo o diretório de salvamento. - O modelo é carregado fornecendo um diretório local como `pretrained_model_name_or_path` e um arquivo JSON de configuração chamado *config.json* é encontrado no diretório.

state_dict (`dict[str, torch.Tensor]`, *opcional*) : Um dicionário de estado para usar em vez de um dicionário de estado carregado de um arquivo de pesos salvos. Essa opção pode ser usada se você quiser criar um modelo a partir de uma configuração pré-treinada, mas carregar seus próprios pesos. Nesse caso, no entanto, você deve verificar se o uso de [save_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.save_pretrained) e [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) não é uma opção mais simples.

cache_dir (`Union[str, os.PathLike]`, *opcional*) : Caminho para um diretório no qual a configuração de um modelo pré-treinado baixado deve ser armazenada em cache, caso o cache padrão não deva ser usado.

ignore_mismatched_sizes (`bool`, *opcional*, padrão `False`) : Se deve ou não lançar um erro caso alguns dos pesos do checkpoint não tenham o mesmo tamanho que os pesos do modelo (por exemplo, se você estiver instanciando um modelo com 10 rótulos a partir de um checkpoint com 3 rótulos).

force_download (`bool`, *opcional*, padrão `False`) : Indica se deve forçar o (re-)download dos pesos do modelo e dos arquivos de configuração, sobrescrevendo as versões em cache, caso existam.

proxies (`dict[str, str]`, *opcional*) : Um dicionário de servidores proxy a serem usados por protocolo ou endpoint, por exemplo, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Os proxies são usados em cada solicitação.

output_loading_info(`bool`, *opcional*, padrão `False`) : Indica se deve ou não retornar também um dicionário contendo chaves ausentes, chaves inesperadas e mensagens de erro.

local_files_only(`bool`, *opcional*, padrão `False`) : Indica se deve considerar apenas arquivos locais (ou seja, não tentar baixar o modelo).

token (`str` ou `bool`, *opcional*) : O token a ser usado como autorização HTTP bearer para arquivos remotos. Se `True`, ou não especificado, usará o token gerado ao executar `hf auth login` (armazenado em `~/.huggingface`).

revision (`str`, *opcional*, padrão `"main"`) : A versão específica do modelo a ser usada. Pode ser o nome de uma branch, o nome de uma tag ou um id de commit, pois usamos um sistema baseado em git para armazenar modelos e outros artefatos no huggingface.co, portanto `revision` pode ser qualquer identificador permitido pelo git.    Para testar um pull request que você fez no Hub, você pode passar `revision="refs/pr/<pr_number>"`.

attn_implementation (`str`, *opcional*) : A implementação de atenção a ser usada no modelo (se aplicável). Pode ser uma das seguintes opções - `"eager"` (implementação manual da atenção) - `"sdpa"` (usando [`F.scaled_dot_product_attention`](https://pytorch.org/docs/master/generated/torch.nn.functional.scaled_dot_product_attention.html)) - `"flash_attention_2"` (usando [Dao-AILab/flash-attention](https://github.com/Dao-AILab/flash-attention)) - `"flash_attention_3"` (usando [Dao-AILab/flash-attention/hopper](https://github.com/Dao-AILab/flash-attention/tree/main/hopper)) - `"flash_attention_4"` (usando [Dao-AILab/flash-attention/flash_attn/cute](https://github.com/Dao-AILab/flash-attention/tree/main/flash_attn/cute)). Por padrão, se disponível, o SDPA será utilizado. Caso contrário, o padrão é a implementação manual `"eager"`. Aceita referências de kernels do HF no formato: /[@][:]  -  e  são sequências quaisquer que não contenham "/" nem ":". - "@" é opcional (branch, tag ou commit-ish), por exemplo, "@main", "@v1.2.0", "@abc123". - ":" é opcional e seleciona uma função dentro do repositório do kernel. - Ambas as opções podem aparecer juntas e apenas nesta ordem: @revision primeiro, depois :kernel_name. - Permitimos intencionalmente um prefixo inicial "|" (por exemplo, "flash|...") porque o código o remove antes do carregamento; '|' não é excluído nas classes de caracteres aqui.  Exemplos que correspondem: "org/model" "org/model@main" "org/model:custom_kernel" "org/model@v1.2.3:custom_kernel"

experts_implementation (`str`, *opcional*) : A implementação de especialistas a ser usada no modelo (se aplicável). Pode ser uma das seguintes:  - `"eager"` (implementação sequencial das multiplicações de matrizes dos especialistas). - `"batched_mm"` (usando [`torch.bmm`](https://pytorch.org/docs/stable/generated/torch.bmm.html)). - `"grouped_mm"` (usando [`torch.nn.functional.grouped_mm`](https://docs.pytorch.org/docs/main/generated/torch.nn.functional.grouped_mm.html)).  Por padrão, se o modelo for compatível, `"grouped_mm"` será usado. Caso contrário, o padrão é a implementação manual `"eager"`.

**Parâmetros para inferência de modelos grandes:**

dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : Substitui o `torch_dtype` padrão e carrega o modelo em um `dtype` específico. As diferentes opções são:  1. `torch.float16` ou `torch.bfloat16` ou `torch.float`: carrega em um `dtype` especificado, ignorando o `config.dtype` do modelo, se existir. Se não for especificado - o modelo será carregado em `torch.float` (fp32).  2. `"auto"` - Será tentado o uso de uma entrada `dtype` ou `torch_dtype` no arquivo `config.json` do modelo. Se essa entrada não for encontrada, em seguida, verifica-se o `dtype` do primeiro peso no checkpoint que seja de um tipo de ponto flutuante e usa-se esse como `dtype`. Isso carregará o modelo usando o `dtype` em que ele foi salvo no final do treinamento. Não pode ser usado como indicador de como o modelo foi treinado. Isso porque ele pode ter sido treinado em um dos dtypes de meia precisão, mas salvo em fp32.  3. Uma string que seja um `torch.dtype` válido. Por exemplo, "float32" carrega o modelo em `torch.float32`, "float16" carrega em `torch.float16` etc.    Para alguns modelos, o `dtype` em que foram treinados é desconhecido - você pode tentar verificar o paper do modelo ou entrar em contato com os autores e pedir que adicionem essa informação ao card do modelo e insiram a entrada `dtype` ou `torch_dtype` em `config.json` no hub.

device_map (`str` ou `dict[str, Union[int, str, torch.device]]` ou `int` ou `torch.device`, *opcional*) : Um mapa que especifica para onde cada submódulo deve ser enviado. Não é necessário detalhar o nome de cada parâmetro/buffer, pois, uma vez que um determinado nome de módulo esteja incluído, todos os seus submódulos serão enviados para o mesmo dispositivo. Se apenas o dispositivo for passado (*por exemplo*, `"cpu"`, `"cuda:1"`, `"mps"` ou uma posição ordinal de GPU como `1`) no qual o modelo será alocado, o mapa de dispositivos mapeará o modelo inteiro para esse dispositivo. Passar `device_map = 0` significa colocar o modelo inteiro na GPU 0. Para que o Accelerate calcule automaticamente o `device_map` mais otimizado, defina `device_map="auto"`. Para mais informações sobre cada opção, consulte [projetando um mapa de dispositivos](https://hf.co/docs/accelerate/main/en/usage_guides/big_modeling#designing-a-device-map).

max_memory (`Dict`, *opcional*) : Um dicionário de identificador de dispositivo para a memória máxima, caso esteja usando `device_map`. Se não for definido, o padrão será a memória máxima disponível para cada GPU e a RAM de CPU disponível.

distributed_config ([DistributedConfig](/docs/transformers/main/pt/expert_parallelism#transformers.DistributedConfig), *opcional*) : Configuração para carregamento distribuído nativo com paralelismo de tensor ou FSDP2. Passe `DistributedConfig(tp_size=N)` para usar o plano de paralelismo de tensor predefinido de um modelo, `DistributedConfig(tp_plan=...)` para especificar um plano de paralelismo de tensor, ou `DistributedConfig(fsdp_size=N)` para FSDP2. Exige `torchrun` e um grupo de processos inicializado quando `tp_size > 1` ou `fsdp_size > 1`. Mutuamente exclusivo com `device_map`.

device_mesh (`torch.distributed.DeviceMesh`, *opcional*) : Uma malha de dispositivos torch. Se não for fornecida, o padrão será o tamanho do mundo. Usado apenas para paralelismo de tensor por enquanto. Se fornecida, ela deve conter uma dimensão nomeada `"tp"` caso seja > 1 dimensional; essa dimensão será usada para o paralelismo de tensor.

offload_folder (`str` ou `os.PathLike`, *opcional*) : Se o `device_map` contiver qualquer valor `"disk"`, a pasta onde os pesos serão descarregados.

offload_buffers (`bool`, *opcional*) : Se os buffers com os parâmetros do modelo devem ser descarregados (offload) ou não.

quantization_config (`Union[QuantizationConfigMixin,Dict]`, *opcional*) : Um dicionário de parâmetros de configuração ou um objeto QuantizationConfigMixin para quantização (por exemplo, bitsandbytes, gptq).

subfolder (`str`, *opcional*, padrão `""`) : Caso os arquivos relevantes estejam localizados em uma subpasta do repositório do modelo no huggingface.co, você pode especificar o nome da pasta aqui.

variant (`str`, *opcional*) : Se especificado, carrega os pesos a partir do nome de arquivo `variant`, *por exemplo* pytorch_model..bin.

use_safetensors (`bool`, *opcional*, padrão `None`) : Se deve ou não usar checkpoints de `safetensors`. O padrão é `None`. Se não for especificado e `safetensors` não estiver instalado, será definido como `False`.

weights_only (`bool`, *opcional*, padrão `True`) : Indica se o unpickler deve ser restrito a carregar apenas tensores, tipos primitivos, dicionários e quaisquer tipos adicionados via torch.serialization.add_safe_globals(). Quando definido como False, é possível carregar pesos de subclasses de tensor wrapper.

disable_mmap (`bool`, *opcional*) : Se deve desabilitar o mapeamento de memória ao carregar checkpoints em safetensors. Quando `None` (padrão), é detectado automaticamente como `True` quando o checkpoint está em um sistema de arquivos FUSE `hf-mount` (usado por HF Spaces/Endpoints), onde mmap + page-faults paralelos podem causar deadlock. Quando `True`, os arquivos são lidos totalmente para a memória e analisados com `safetensors.torch.load`. Quando `False`, o carregador com mapeamento de memória padrão é sempre usado.

fusion_config (`dict[str, bool | dict[str, Any]]`, *opcional*) : Configuração de fusão opcional aplicada antes da instanciação do modelo. Cada chave habilita uma família de fusão e seu valor pode ser `True` para habilitar aquela fusão com as opções padrão ou um dicionário de opções específicas da família. Por exemplo, `{"patch_embeddings": True}` habilita a fusão de incorporação de patches. Isso deve ser usado apenas como uma otimização de inferência, pois pode alterar ligeiramente as saídas. Se omitido, `from_pretrained()` recorre a `config.fusion_config` quando disponível. Consulte o guia de mapeamento de fusão em `docs/source/en/fusion_mapping.md` para mais detalhes.

key_mapping (`dict[str, str], *opcional*) : Um mapeamento potencial dos nomes dos pesos, caso esteja usando um modelo no Hub que seja compatível com uma arquitetura do Transformers, mas que não foi convertido de acordo.

kwargs (dicionário restante de argumentos por palavra-chave, *opcional*) : Pode ser usado para atualizar o objeto de configuração (após ele ser carregado) e iniciar o modelo (por exemplo, `output_attentions=True`). O comportamento difere dependendo de uma `config` ser fornecida ou carregada automaticamente:  - Se uma configuração for fornecida com `config`, `**kwargs` será passado diretamente para o método `__init__` do modelo subjacente (assumimos que todas as atualizações relevantes à configuração já foram feitas) - Se uma configuração não for fornecida, `kwargs` será primeiro passado para a função de inicialização da classe de configuração ([from_pretrained()](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained)). Cada chave de `kwargs` que corresponder a um atributo de configuração será usada para sobrescrever o referido atributo com o valor de `kwargs` fornecido. As chaves restantes que não corresponderem a nenhum atributo de configuração serão passadas para a função `__init__` do modelo subjacente.

Instancie um modelo pytorch pré-treinado a partir de uma configuração de modelo pré-treinado.

O modelo é definido no modo de avaliação por padrão usando `model.eval()` (os módulos Dropout são desativados). Para treinar o modelo, você deve primeiro redefinir o modo de treinamento com `model.train()`.

O aviso *Weights from XXX not initialized from pretrained model* significa que os pesos de XXX não vêm pré-treinados junto com o restante do modelo. Cabe a você treinar esses pesos com uma tarefa de ajuste fino de nível inferior.

O aviso *Weights from XXX not used in YYY* significa que a camada XXX não é utilizada por YYY, portanto, esses pesos são descartados.

Ative o modo especial ["offline-mode"](https://huggingface.co/transformers/installation.html#offline-mode) para usar este método em um ambiente com firewall.

Exemplos:

```python
>>> from transformers import BertConfig, BertModel

>>> # Download model and configuration from huggingface.co and cache.
>>> model = BertModel.from_pretrained("google-bert/bert-base-uncased")
>>> # Model was saved using *save_pretrained('./test/saved_model/')* (for example purposes, not runnable).
>>> model = BertModel.from_pretrained("./test/saved_model/")
>>> # Update configuration during loading.
>>> model = BertModel.from_pretrained("google-bert/bert-base-uncased", output_attentions=True)
>>> assert model.config.output_attentions == True
```

#### get_compiled_call[[transformers.PreTrainedModel.get_compiled_call]]

```python
get_compiled_call(compile_config: transformers.generation.configuration_utils.CompileConfig | None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4797)

Retorna uma versão compilada com `torch.compile` de `self.__call__`. Isso é útil para escolher dinamicamente entre `forward` não compilado/compilado durante a inferência, especialmente para alternar entre prefill (onde não queremos usar a versão compilada para evitar a recomputação do grafo com novos formatos) e decodificação iterativa (onde queremos as acelerações da versão compilada com formatos estáticos).

#### get_decoder[[transformers.PreTrainedModel.get_decoder]]

```python
get_decoder()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2254)

Busca de melhor esforço do módulo *decoder*.

Ordem das tentativas (cobre ~85 % dos usos atuais):

1. `self.decoder/self.language_model/self.text_model`
2. `self.base_model`                  (muitos wrappers armazenam o decoder aqui)
3. `self.base_model.get_decoder()`    (wrappers aninhados)
4. fallback: lançar exceção para os poucos modelos exóticos que exigem uma regra personalizada

#### get_encoder[[transformers.PreTrainedModel.get_encoder]]

```python
get_encoder(modality: str | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2196)

Busca de melhor esforço do módulo *encoder*. Se fornecido com o argumento `modality`, ele procura por um codificador específico da modalidade em modelos multimodais (por exemplo, "image_encoder"). Por padrão, a função retorna o codificador de texto do modelo, se houver, e caso contrário retorna `self`.

Os valores possíveis para `modality` são "image", "video" e "audio".

#### get_expanded_tied_weights_keys[[transformers.PreTrainedModel.get_expanded_tied_weights_keys]]

```python
get_expanded_tied_weights_keys(all_submodels: bool = False)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2416)

Retorna as chaves de pesos vinculados expandidos (caso contenham módulos ou padrões de expressão regular) apenas para o modelo atual, ou recursivamente para todos os submodelos, se `all_submodels=True` (ou seja, ele reavaliará os valores de configuração para todos os submodelos).

Para a grande maioria dos modelos, é necessário apenas vincular os embeddings, de modo que o modelo possua a propriedade interna `_tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"}`. Nesse caso, o mapeamento já está "expandido", ou seja, já contém os parâmetros completos, e esta função simplesmente retornará uma cópia da propriedade. Para padrões mais complexos, por exemplo, para `DFineForObjectDetection`, temos o seguinte atributo

```
_tied_weights_keys = {
    r"bbox_embed.(?![0])\d+": "bbox_embed.0",
    r"class_embed.(?![0])\d+": "class_embed.0",
    "model.decoder.class_embed": "class_embed",
    "model.decoder.bbox_embed": "bbox_embed",
}
```

Nesse caso, a função consulta todos os parâmetros e buffers do modelo e corresponde a todos os parâmetros,

retornando o seguinte:
```
{
    'bbox_embed.1.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'bbox_embed.1.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    'bbox_embed.1.layers.1.bias': 'bbox_embed.0.layers.1.bias',
    'bbox_embed.1.layers.1.weight': 'bbox_embed.0.layers.1.weight',
    'bbox_embed.1.layers.2.bias': 'bbox_embed.0.layers.2.bias',
    'bbox_embed.1.layers.2.weight': 'bbox_embed.0.layers.2.weight',
    'bbox_embed.2.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'bbox_embed.2.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    ...
    'class_embed.1.bias': 'class_embed.0.bias',
    'class_embed.1.weight': 'class_embed.0.weight',
    'class_embed.2.bias': 'class_embed.0.bias',
    'class_embed.2.weight': 'class_embed.0.weight',
    ...
    'model.decoder.class_embed.0.bias': 'class_embed.0.bias',
    'model.decoder.class_embed.0.weight': 'class_embed.0.weight',
    'model.decoder.class_embed.1.bias': 'class_embed.0.bias',
    'model.decoder.class_embed.1.weight': 'class_embed.0.weight',
    ...
    'model.decoder.bbox_embed.0.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'model.decoder.bbox_embed.0.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    'model.decoder.bbox_embed.0.layers.1.bias': 'bbox_embed.0.layers.1.bias',
    'model.decoder.bbox_embed.0.layers.1.weight': 'bbox_embed.0.layers.1.weight',
    ...
}
```

ou seja, todos os parâmetros que correspondem aos padrões de regex e módulos em `_tied_weights_keys`

#### get_experts_implementation[[transformers.PreTrainedModel.get_experts_implementation]]

```python
get_experts_implementation()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2064)

Retorna a implementação dos especialistas deste modelo e de seus submodelos, como um `dict` no formato aceito por `set_experts_implementation` (`""` para este modelo e uma entrada por sub_config). Este é o par de `set_experts_implementation`, por exemplo, para capturar a implementação atual e restaurá-la posteriormente.

#### get_memory_footprint[[transformers.PreTrainedModel.get_memory_footprint]]

```python
get_memory_footprint(return_buffers = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3676)

**Parâmetros:**

return_buffers (`bool`, *opcional*, padrão `True`) : Se deve retornar o tamanho dos tensores de buffer no cálculo da pegada de memória. Buffers são tensores que não exigem gradientes e não estão registrados como parâmetros. Por exemplo, a média e o desvio padrão em camadas de normalização por lote. Consulte: https://discuss.pytorch.org/t/what-pytorch-means-by-buffers/120266/2

Obtenha a pegada de memória de um modelo. Isso retornará a pegada de memória do modelo atual em bytes. Útil para fazer o benchmark da pegada de memória do modelo atual e projetar alguns testes. Solução inspirada nas discussões do PyTorch: https://discuss.pytorch.org/t/gpu-memory-that-model-uses/56822/2

#### get_parameter_or_buffer[[transformers.PreTrainedModel.get_parameter_or_buffer]]

```python
get_parameter_or_buffer(target: str)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4964)

Retorna o parâmetro ou buffer indicado por `target`, caso exista; caso contrário, lança um erro. Esta função combina `get_parameter()` e `get_buffer()` em uma única função conveniente. Se o alvo for um atributo `_extra_state`, ela retornará o estado extra fornecido pelo módulo. Observe que isso só funciona se `target` for uma folha do modelo.

#### gradient_checkpointing_disable[[transformers.PreTrainedModel.gradient_checkpointing_disable]]

```python
gradient_checkpointing_disable()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3276)

Alias obsoleto de [activation_checkpointing_disable()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.activation_checkpointing_disable), será removido na v6.

#### gradient_checkpointing_enable[[transformers.PreTrainedModel.gradient_checkpointing_enable]]

```python
gradient_checkpointing_enable(gradient_checkpointing_kwargs = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3191)

Alias obsoleto de [activation_checkpointing_enable()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.activation_checkpointing_enable), será removido na v6.

#### init_weights[[transformers.PreTrainedModel.init_weights]]

```python
init_weights()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3098)

Inicialize e vincule os pesos, se necessário. Se estiver usando um `PreTrainedModel` personalizado, você precisa implementar a lógica de inicialização em `_init_weights`.

#### initialize_weights[[transformers.PreTrainedModel.initialize_weights]]

```python
initialize_weights()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2386)

Isso é equivalente a chamar `self.apply(self._initialize_weights)`, mas trata corretamente modelos compostos. Esta função despacha dinamicamente a função `init_weights` correta para os módulos à medida que avançamos no grafo de módulos ao longo da recursão. Ela pode lidar com um número arbitrário de submodelos. Sem ela, cada modelo composto teria que recursar uma segunda vez em todos os submodelos explicitamente no `_init_weights` mais externo, o que é extremamente propenso a erros e ineficiente.

#### is_custom_code[[transformers.PreTrainedModel.is_custom_code]]

```python
is_custom_code()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L5018)

Retorna se o modelo atual é de código personalizado, ou seja, se o código foi carregado do hub ou definido em qualquer módulo/sessão específico do usuário.

#### is_remote_code[[transformers.PreTrainedModel.is_remote_code]]

```python
is_remote_code()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L5012)

Retorna se o modelo atual é de código personalizado, ou seja, código carregado do hub, ou uma classe que acabamos de registrar via `register_for_auto_class`.

#### mark_tied_weights_as_initialized[[transformers.PreTrainedModel.mark_tied_weights_as_initialized]]

```python
mark_tied_weights_as_initialized(loading_info)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4936)

Adiciona a flag `_is_hf_initialized` nos parâmetros que serão vinculados, a fim de evitar sua inicialização posterior, já que eles serão vinculados (sobrescritos) de qualquer forma. Isso é muito importante, pois a maioria dos embeddings é vinculada e são parâmetros enormes (os vocabulários frequentemente têm 256k), de modo que executar inicializações neles é muito custoso.

#### named_non_persistent_buffers[[transformers.PreTrainedModel.named_non_persistent_buffers]]

```python
named_non_persistent_buffers(recurse: bool = True, remove_duplicate: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4988)

Semelhante a `named_buffers`, mas retorna apenas os não persistentes. É útil, pois não é totalmente óbvio saber se eles são persistentes ou não.

#### post_init[[transformers.PreTrainedModel.post_init]]

```python
post_init()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1289)

Um método executado ao final da inicialização de cada modelo Transformer, para executar código que requer que os módulos do modelo estejam devidamente inicializados (como a inicialização de pesos). Ele também é usado para obter todas as propriedades estáticas corretas (planos de paralelismo, tied_weights_keys, _keep_in_fp32_modules, etc.) corretamente no caso de modelos compostos (ou seja, o modelo de nível superior deve conhecer essas propriedades de seus filhos).

#### register_for_auto_class[[transformers.PreTrainedModel.register_for_auto_class]]

```python
register_for_auto_class(auto_class = 'AutoModel')
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4643)

**Parâmetros:**

auto_class (`str` ou `type`, *opcional*, padrão `"AutoModel"`) : A classe auto com a qual registrar este novo modelo.

Registre esta classe com uma auto class específica. Isso deve ser usado apenas para modelos personalizados, pois os modelos da biblioteca já estão mapeados com uma auto class.

#### resize_token_embeddings[[transformers.PreTrainedModel.resize_token_embeddings]]

```python
resize_token_embeddings(new_num_tokens: int | None = None, pad_to_multiple_of: int | None = None, mean_resizing: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2633)

**Parâmetros:**

new_num_tokens (`int`, *opcional*) : O novo número de tokens na matriz de incorporação. Aumentar o tamanho adicionará vetores recém-inicializados no final. Reduzir o tamanho removerá vetores do final. Se não for fornecido ou for `None`, retorna apenas um ponteiro para o módulo de tokens `torch.nn.Embedding` de entrada do modelo, sem fazer nada.

pad_to_multiple_of (`int`, *opcional*) : Se definido, o parâmetro de preenchimento da matriz de incorporação será ajustado para um múltiplo do valor fornecido. Se `new_num_tokens` for definido como `None`, apenas o preenchimento da incorporação será ajustado para um múltiplo de `pad_to_multiple_of`. Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação `>= 7.5` (Volta) ou em TPUs, que se beneficiam de ter comprimentos de sequência que sejam múltiplos de 128. Para mais detalhes sobre isso ou ajuda na escolha do valor correto para o redimensionamento, consulte este guia: https://docs.nvidia.com/deeplearning/performance/dl-performance-matrix-multiplication/index.html#requirements-tc

mean_resizing (`bool`) : Se as embeddings adicionadas devem ser inicializadas a partir de uma distribuição normal multivariada que possui a média e a covariância das embeddings antigas, ou se devem ser inicializadas com uma distribuição normal que tem média zero e desvio padrão igual a `config.initializer_range`. Definir `mean_resizing` como `True` é útil ao aumentar o tamanho das embeddings de modelos de linguagem causais, pois as probabilidades dos tokens gerados não serão afetadas pelas embeddings adicionadas, já que inicializar as novas embeddings com a média das embeddings antigas reduzirá a divergência de KL entre a probabilidade do próximo token antes e depois da adição das novas embeddings. Consulte este artigo para mais informações: https://nlp.stanford.edu/~johnhew/vocab-expansion.html

**Retorna:** `torch.nn.Embedding`

Ponteiro para o Módulo de Embeddings dos tokens de entrada do modelo.

Redimensiona a matriz de embeddings de tokens de entrada do modelo se `new_num_tokens != config.vocab_size`.

Cuida de vincular os pesos das embeddings em seguida, se a classe do modelo tiver um método `tie_weights()`.

#### save_pretrained[[transformers.PreTrainedModel.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, is_main_process: bool = True, state_dict: dict | None = None, push_to_hub: bool = False, max_shard_size: int | str = '50GB', variant: str | None = None, token: str | bool | None = None, save_peft_format: bool = True, save_original_format: bool = True, distributed_checkpoint: bool = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3310)

**Parâmetros:**

save_directory (`str` ou `os.PathLike`) : Diretório para salvar. Será criado se não existir.

is_main_process (`bool`, *opcional*, padrão `True`) : Indica se o processo que está chamando esta função é o processo principal. Útil em treinamento distribuído, como em TPUs, quando é necessário chamar esta função em todos os processos. Nesse caso, defina `is_main_process=True` apenas no processo principal para evitar condições de corrida.

state_dict (dicionário aninhado de `torch.Tensor`) : O dicionário de estado do modelo a ser salvo. O padrão será `self.state_dict()`, mas pode ser usado para salvar apenas partes do modelo ou quando forem necessárias precauções especiais ao recuperar o dicionário de estado de um modelo (como ao usar paralelismo de modelo).

push_to_hub (`bool`, *opcional*, padrão `False`) : Indica se o modelo deve ser enviado para o Hugging Face model hub após ser salvo. Você pode especificar o repositório de destino com `repo_id` (por padrão, será usado o nome de `save_directory` no seu namespace).

max_shard_size (`int` ou `str`, *opcional*, padrão `"50GB"`) : O tamanho máximo de um checkpoint antes de ser fragmentado. Os fragmentos do checkpoint terão, então, cada um um tamanho menor que esse valor. Se expresso como string, deve ser composto por dígitos seguidos de uma unidade (como `"5MB"`).    Se um único peso do modelo for maior que `max_shard_size`, ele ficará em seu próprio fragmento de checkpoint, que será maior que `max_shard_size`.

variant (`str`, *opcional*) : Se especificado, os pesos são salvos no formato model..safetensors.

token (`str` ou `bool`, *opcional*) : O token a ser usado como autorização HTTP bearer para arquivos remotos. Se `True`, ou não especificado, usará o token gerado ao executar `hf auth login` (armazenado em `~/.huggingface`).

save_peft_format (`bool`, *opcional*, padrão `True`) : Para compatibilidade reversa com a biblioteca PEFT, caso os pesos do adaptador estejam anexados ao modelo, todas as chaves do state dict dos adaptadores precisam ser prefixadas com `base_model.model`. Usuários avançados podem desabilitar esse comportamento definindo `save_peft_format` como `False`.

save_original_format (`bool`, *opcional*, padrão `True`) : Para compatibilidade reversa com as versões anteriores do `transformers`, você pode salvar o checkpoint com seu mapeamento reverso. O mapeamento reverso precisa existir mesmo que o modelo tenha sido carregado de um checkpoint legado None.

distributed_checkpoint (`bool`, *opcional*, padrão `False`) : Ao salvar um modelo particionado com FSDP ou TP, grava os safetensors usando checkpointing distribuído (DCP) em vez de reunir os pesos na CPU primeiro. Todos os ranks devem chamar este método. Quando `False`, os pesos são reunidos na CPU no rank 0 via `gather_full_state_dict` antes de serem gravados. É destinado apenas para salvar e retomar o treinamento; defina como `False` se você quiser todos os recursos de `save_pretrained`. Com `push_to_hub=True`, o rank 0 consolida o checkpoint em um subdiretório `consolidated/` e faz o upload desse diretório. Requer `torch>=2.7`.

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave adicionais passados ao método [push_to_hub()](/docs/transformers/main/pt/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Salve um modelo e seu arquivo de configuração em um diretório, para que ele possa ser recarregado usando o método de classe [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained).

#### set_attn_implementation[[transformers.PreTrainedModel.set_attn_implementation]]

```python
set_attn_implementation(attn_implementation: str | dict, allow_all_kernels: bool = False)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1960)

**Parâmetros:**

attn_implementation (`str` ou `dict`) : A implementação de atenção a ser definida para este modelo. Pode ser uma `str`, caso em que será distribuída para todos os submodelos, se aplicável, ou um `dict` em que as chaves são os nomes dos sub_configs, caso em que cada submodelo distribuirá o valor correspondente (a si mesmo e a todos os submodelos aninhados nele). Um valor pode, por sua vez, ser um `dict` no mesmo formato, para direcionar os sub_configs desse submodelo (como ao inicializar uma config com um `attn_implementation` dict aninhado).

allow_all_kernels (`bool`, opcional) : Se deve carregar kernels de repositórios não verificados do hub, caso `attn_implementation` seja um kernel personalizado fora do repositório do hub `kernels-community`.

Defina o `attn_implementation` solicitado para este modelo.

#### set_decoder[[transformers.PreTrainedModel.set_decoder]]

```python
set_decoder(decoder)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2277)

Setter simétrico. Espelha a lógica de busca usada em `get_decoder`.

#### set_encoder[[transformers.PreTrainedModel.set_encoder]]

```python
set_encoder(encoder, modality: str | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2228)

Definidor simétrico. Espelha a lógica de consulta usada em `get_encoder`.

#### set_experts_implementation[[transformers.PreTrainedModel.set_experts_implementation]]

```python
set_experts_implementation(experts_implementation: str | dict)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2077)

**Parâmetros:**

experts_implementation (`str` ou `dict`) : A implementação de especialistas a ser definida para este modelo. Pode ser uma `str`, caso em que será distribuída para todos os submodelos, se aplicável, ou um `dict` em que as chaves são os nomes dos sub_configs, caso em que cada submodelo distribuirá o valor correspondente.

Defina o `experts_implementation` solicitado para este modelo.

#### set_use_kernels[[transformers.PreTrainedModel.set_use_kernels]]

```python
set_use_kernels(use_kernels, kernel_config: transformers.utils.kernel_config.KernelConfig | None = None, mode: Mode | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3850)

**Parâmetros:**

use_kernels (`bool`) : Indica se a biblioteca `kernels` deve ser usada para kernelizar algumas camadas do modelo.

kernel_config (`KernelConfig`, *opcional*) : A configuração de kernel a ser usada para kernelizar o modelo. Se `None`, o mapeamento de kernel padrão será usado.

mode (`Mode`, *opcional*) : O modo que deve ser aplicado durante o `kernelize`. Opcional, padrão é o modo de treinamento ou inferência, com base na flag interna `training`.

Defina se a biblioteca `kernels` deve ser usada para kernelizar algumas camadas do modelo.

#### tie_weights[[transformers.PreTrainedModel.tie_weights]]

```python
tie_weights(missing_keys: set[str] | None = None, recompute_mapping: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2530)

Vincule os pesos do modelo. Se `recompute_mapping=False` (padrão quando chamado internamente), ele dependerá do atributo `model.all_tied_weights_keys`, que contém o mapeamento `{target: source}` para os parâmetros vinculados. Se `recompute_mapping=True`, ele reavaliará todos os submodelos internos e sua configuração para determinar os parâmetros que precisam ser vinculados. Este é o padrão quando `model.tie_weights()` é chamado isoladamente, fora de `__init__` e `from_pretrained`, caso os valores da configuração tenham sido alterados em algum lugar.

Observe que, durante o `from_pretrained`, a vinculação é *simétrica*: se o mapeamento indica "tie target -> source", mas `source` está ausente no checkpoint enquanto `target` existe, fazemos a *troca* de source e target para que ainda seja possível vincular tudo ao parâmetro que realmente existe.

#### para[[transformers.PreTrainedModel.to]]

```python
to(*args, **kwargs)
```

Um valor simulado para um caminho pontilhado (por exemplo, `torch.float32`): as cadeias de acesso a atributos e as chamadas se comportam como decoradores de passagem, o `repr` é o caminho pontilhado, e o uso como classe base substitui uma base de `type` simples (PEP 560 `__mro_entries__`), de modo que as subclasses reais mantêm um metaclass normal e o `inspect.signature` lê o `__init__` real delas, em vez do de um mock.

#### warn_if_padding_and_no_attention_mask[[transformers.PreTrainedModel.warn_if_padding_and_no_attention_mask]]

```python
warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4665)

Exibe um aviso único se os input_ids parecerem conter preenchimento (padding) e nenhuma máscara de atenção foi fornecida.

Modelos personalizados também devem incluir um `_supports_assign_param_buffer`, que determina se o superfast init pode ser aplicado ao modelo específico. Indícios de que seu modelo precisa disso são se `test_save_and_load_from_pretrained` falhar. Se for o caso, defina isso como `False`.

## ModuleUtilsMixin[[transformers.modeling_utils.ModuleUtilsMixin]]

#### transformers.modeling_utils.ModuleUtilsMixin[[transformers.modeling_utils.ModuleUtilsMixin]]

```python
transformers.modeling_utils.ModuleUtilsMixin()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L894)

Algumas utilidades para `torch.nn.Modules`, para serem usadas como um mixin.

#### num_parameters[[transformers.modeling_utils.ModuleUtilsMixin.num_parameters]]

```python
num_parameters(only_trainable: bool = False, exclude_embeddings: bool = False)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L914)

**Parâmetros:**

only_trainable (`bool`, *opcional*, padrão `False`) : Se deve retornar apenas o número de parâmetros treináveis

exclude_embeddings (`bool`, *opcional*, padrão `False`) : Se deve retornar apenas o número de parâmetros que não são embeddings

**Retorna:** `int`

O número de parâmetros.

Obtém o número de parâmetros (opcionalmente, treináveis ou não de incorporação) no módulo.

## Enviando para o Hub[[transformers.utils.PushToHubMixin]]

#### transformers.utils.PushToHubMixin[[transformers.utils.PushToHubMixin]]

```python
transformers.utils.PushToHubMixin()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L728)

Uma Mixin que contém a funcionalidade para enviar um modelo ou tokenizer para o hub.

#### push_to_hub[[transformers.utils.PushToHubMixin.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L822)

**Parâmetros:**

repo_id (`str`) : O nome do repositório para o qual você deseja enviar seu {object}. Deve conter o nome da sua organização ao enviar para uma organização específica.

commit_message (`str`, *opcional*) : Mensagem a ser commitada durante o push. O valor padrão será `"Upload {object}"`.

commit_description (`str`, *opcional*) : A descrição do commit que será criado

private (`bool`, *opcional*) : Se deve tornar o repositório privado. Se `None` (padrão), o repositório será público, a menos que o padrão da organização seja privado. Este valor é ignorado se o repositório já existir.

token (`bool` ou `str`, *opcional*) : O token a ser usado como autorização bearer HTTP para arquivos remotos. Se `True` (padrão), usará o token gerado ao executar `hf auth login` (armazenado em `~/.huggingface`).

revision (`str`, *opcional*) : Branch para a qual os arquivos enviados serão enviados.

create_pr (`bool`, *opcional*, padrão `False`) : Se deve ou não criar um PR com os arquivos enviados ou fazer o commit diretamente.

max_shard_size (`int` ou `str`, *opcional*, padrão `"50GB"`) : Aplicável apenas a modelos. O tamanho máximo de um checkpoint antes de ser fragmentado. Os fragmentos do checkpoint terão, então, cada um um tamanho menor que esse valor. Se expresso como string, deve conter dígitos seguidos de uma unidade (como `"5MB"`).

tags (`list[str]`, *opcional*) : Lista de tags para enviar no Hub.

Faça o upload do {object_files} para o 🤗 Model Hub.

Exemplos:

```python
from transformers import {object_class}

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

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

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