# Configuração

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

Cada classe de configuração derivada implementa atributos específicos do modelo. Os atributos comuns presentes em todas as classes de configuração são: `hidden_size`, `num_attention_heads` e `num_hidden_layers`. Os modelos de texto implementam, além disso: `vocab_size`.

## PreTrainedConfig[[transformers.PreTrainedConfig]]

#### transformers.PreTrainedConfig[[transformers.PreTrainedConfig]]

```python
transformers.PreTrainedConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None)
```

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

**Parâmetros:**

name_or_path (`str`, *opcional*, padrão `""`) : Armazena a string que foi passada para [PreTrainedModel.from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) como `pretrained_model_name_or_path` se a configuração foi criada com tal método.

output_hidden_states (`bool`, *opcional*, padrão `False`) : Se o modelo deve ou não retornar todos os hidden-states.

output_attentions (`bool`, *opcional*, padrão `False`) : Se o modelo deve retornar todas as atenções.

return_dict (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

is_encoder_decoder (`bool`, *opcional*, padrão `False`) : Indica se o modelo é usado como codificador/decodificador ou não.

chunk_size_feed_forward (`int`, *opcional*, padrão `0`) : O tamanho do bloco de todas as camadas feed forward nos blocos de atenção residual. Um tamanho de bloco de `0` significa que a camada feed forward não é dividida em blocos. Um tamanho de bloco de n significa que a camada feed forward processa `n` < sequence_length embeddings por vez. Para mais informações sobre a divisão em blocos de camadas feed forward, consulte [Como funciona a divisão em blocos de camadas feed forward?](../glossary.html#feed-forward-chunking).

per_layer_config (`dict[int | str, dict[str, Any]]`, *opcional*) : Um mapeamento esparsa de índices de camadas para substituições de atributos de configuração. Cada chave é um índice de camada, e cada valor contém os atributos que diferem da configuração global para essa camada.

tie_last_hidden_states (`bool`, *opcional*) : Se `hidden_states[-1]` deve ser o `last_hidden_state` pós-normalização final, em vez do estado oculto pré-normalização final. Se não definido, o padrão embutido do modelo é utilizado.

**Parâmetros para tarefas de ajuste fino:**

architectures (`list[str]`, *opcional*) : Arquiteturas de modelo que podem ser usadas com os pesos pré-treinados do modelo.

id2label (`dict[int, str]`, *opcional*) : Um mapa de índice (por exemplo, índice de previsão ou índice de alvo) para rótulo.

label2id (`dict[str, int]`, *opcional*) : Um mapa de rótulo para índice do modelo.

num_labels (`int`, *opcional*) : Número de rótulos a serem usados na última camada adicionada ao modelo, geralmente para uma tarefa de classificação.

problem_type (`str`, *opcional*) : Tipo de problema para modelos `XxxForSequenceClassification`. Pode ser um de `"regression"`, `"single_label_classification"` ou `"multi_label_classification"`.

**Parâmetros específicos do PyTorch:**

dtype (`str`, *opcional*) : O `dtype` dos pesos. Este atributo pode ser usado para inicializar o modelo com um `dtype` não padrão (normalmente `float32`), permitindo assim uma alocação de armazenamento otimizada. Por exemplo, se o modelo salvo for `float16`, idealmente queremos carregá-lo de volta usando a quantidade mínima de memória necessária para carregar pesos `float16`.

Classe base para todas as classes de configuração. Trata alguns parâmetros comuns a todas as configurações de modelos, bem como métodos para carregar/baixar/salvar configurações.

Um arquivo de configuração pode ser carregado e salvo no disco. Carregar o arquivo de configuração e usar esse arquivo para inicializar um modelo **não** carrega os pesos do modelo. Ele afeta apenas a configuração do modelo.

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

- **model_type** (`str`) -- Um identificador para o tipo de modelo, serializado no arquivo JSON e usado para recriar o objeto correto no [AutoConfig](/docs/transformers/main/pt/model_doc/auto#transformers.AutoConfig).
- **attribute_map** (`dict[str, str]`) -- Um dicionário que mapeia os nomes de atributos específicos do modelo para a nomenclatura padronizada dos atributos.
- **base_model_tp_plan** (`dict[str, Any]`) -- Um dicionário que mapeia os FQNs dos submódulos de um modelo base para um plano de paralelismo de tensor aplicado ao submódulo quando `model.tensor_parallel` é chamado.
- **base_model_fsdp_plan** (`dict[Any, str]`) -- Um dicionário que mapeia submódulos de um modelo base para uma estratégia de sharding do FSDP2 (por exemplo, `"free_full_weight"` / `"keep_full_weight"`). As chaves podem ser caminhos de módulos com curinga (por exemplo, `"layers.*"`) ou tuplas de caminhos (agrupados em uma única chamada de `fully_shard`).
- **base_model_pp_plan** (`dict[str, tuple[list[str]]]`) -- Um dicionário que mapeia os submódulos de um modelo base para um plano de paralelismo de pipeline, permitindo que os usuários posicionem o submódulo no dispositivo apropriado.

Atributos comuns (presentes em todas as subclasses):

- **vocab_size** (`int`) -- O número de tokens no vocabulário, que também é a primeira dimensão da matriz de embeddings (esse atributo pode estar ausente em modelos que não possuem uma modalidade de texto, como o ViT).
- **hidden_size** (`int`) -- O tamanho oculto do modelo.
- **num_attention_heads** (`int`) -- O número de cabeças de atenção usadas nas camadas de atenção multi-cabeça do modelo.
- **num_hidden_layers** (`int`) -- O número de blocos no modelo.

Definir parâmetros para a geração de sequência na configuração do modelo está obsoleto. Para compatibilidade reversa, o carregamento de alguns deles ainda será possível, mas tentar sobrescrevê-los lançará uma exceção -- você deve defini-los em um [~transformers.GenerationConfig]. Consulte a documentação de [~transformers.GenerationConfig] para mais informações sobre os parâmetros individuais.

#### push_to_hub[[transformers.PreTrainedConfig.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 sua configuração. Deve conter o nome da sua organização ao enviar para uma organização específica.

commit_message (`str`, *opcional*) : Mensagem para o commit ao fazer push. O padrão será `"Upload config"`.

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 de configuração para o 🤗 Model Hub.

Exemplos:

```python
from transformers import AutoConfig

config = AutoConfig.from_pretrained("google-bert/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")
```

#### default_config_fields[[transformers.PreTrainedConfig.default_config_fields]]

```python
default_config_fields()
```

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

Obtém os valores padrão para cada campo anotado em um dataclass, usado para salvar o diff-dict. Para configs criados no v4 com `__init__` personalizado, ele retorna um dicionário vazio, salvando assim todas as chaves em `self.__dict__`. Para configs mais recentes, ele retorna as chaves que possuem padrões declarados como campos, em vez de em `__post_init__`, o que filtra apenas esses campos específicos do arquivo json serializado.

#### dict_dtype_to_str[[transformers.PreTrainedConfig.dict_dtype_to_str]]

```python
dict_dtype_to_str(d: dict[str, Any])
```

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

Verifica se o dicionário passado e seus dicionários aninhados possuem uma chave *dtype* e, se ela não for None, converte torch.dtype em uma string contendo apenas o tipo. Por exemplo, `torch.float32` é convertido na string *"float32"*, que pode então ser armazenada no formato json.

#### from_dict[[transformers.PreTrainedConfig.from_dict]]

```python
from_dict(config_dict: dict[str, Any], **kwargs)
```

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

**Parâmetros:**

config_dict (`dict[str, Any]`) : Dicionário que será usado para instanciar o objeto de configuração. Esse dicionário pode ser obtido de um checkpoint pré-treinado utilizando o método [get_config_dict()](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig.get_config_dict).

kwargs (`dict[str, Any]`) : Parâmetros adicionais a partir dos quais inicializar o objeto de configuração.

**Retorna:** [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig)

O objeto de configuração instanciado a partir desses parâmetros.

Instancia um [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) a partir de um dicionário Python de parâmetros.

#### from_json_file[[transformers.PreTrainedConfig.from_json_file]]

```python
from_json_file(json_file: str | os.PathLike)
```

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

**Parâmetros:**

json_file (`str` ou `os.PathLike`) : Caminho para o arquivo JSON contendo os parâmetros.

**Retorna:** [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig)

O objeto de configuração instanciado a partir desse arquivo JSON.

Instancia um [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) a partir do caminho para um arquivo JSON de parâmetros.

#### from_pretrained[[transformers.PreTrainedConfig.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', **kwargs)
```

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

**Parâmetros:**

pretrained_model_name_or_path (`str` ou `os.PathLike`) : Pode ser:  - uma string, o *model id* de uma configuração de modelo pré-treinado hospedada em um repositório de modelos no huggingface.co. - um caminho para um *diretório* contendo um arquivo de configuração salvo usando o método [save_pretrained()](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig.save_pretrained), por exemplo, `./my_model_directory/`. - um caminho para um arquivo JSON de configuração salvo *file*, por exemplo, `./my_model_directory/configuration.json`.

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

force_download (`bool`, *opcional*, padrão `False`) : Indica se deve forçar o (re)download dos arquivos de configuração e sobrescrever 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.

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>"`.

return_unused_kwargs (`bool`, *opcional*, padrão `False`) : Se `False`, esta função retorna apenas o objeto de configuração final. Se `True`, esta função retorna uma `Tuple(config, unused_kwargs)`, onde *unused_kwargs* é um dicionário composto pelos pares de chave/valor cujas chaves não são atributos de configuração: ou seja, a parte de `kwargs` que não foi usada para atualizar `config` e é, portanto, ignorada.

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.

kwargs (`dict[str, Any]`, *opcional*) : Os valores em kwargs de quaisquer chaves que sejam atributos de configuração serão usados para substituir os valores carregados. O comportamento em relação a pares de chave/valor cujas chaves *não* são atributos de configuração é controlado pelo parâmetro de palavra-chave `return_unused_kwargs`.

**Retorna:** [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig)

O objeto de configuração instanciado a partir deste modelo pré-treinado.

Instancie um [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) (ou uma classe derivada) a partir de uma configuração de modelo pré-treinado.

Exemplos:

```python
# We can't instantiate directly the base class *PreTrainedConfig* so let's show the examples on a
# derived class: BertConfig
config = BertConfig.from_pretrained(
    "google-bert/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("google-bert/bert-base-uncased", output_attentions=True, foo=False)
assert config.output_attentions == True
config, unused_kwargs = BertConfig.from_pretrained(
    "google-bert/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[[transformers.PreTrainedConfig.get_config_dict]]

```python
get_config_dict(pretrained_model_name_or_path: str | os.PathLike, **kwargs)
```

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

**Parâmetros:**

pretrained_model_name_or_path (`str` ou `os.PathLike`) : O identificador do checkpoint pré-treinado do qual queremos o dicionário de parâmetros.

**Retorna:** `tuple[Dict, Dict]`

O(s) dicionário(s) que será(ão) usado(s) para instanciar o objeto de configuração.

A partir de um `pretrained_model_name_or_path`, resolve para um dicionário de parâmetros, a ser usado para instanciar um [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) usando `from_dict`.

#### get_mtp_config[[transformers.PreTrainedConfig.get_mtp_config]]

```python
get_mtp_config()
```

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

Retorna a configuração de texto mtp a ser usada para criar o modelo MTP. Como as camadas MTP são criadas instanciando as mesmas classes do modelo principal, é necessário sobrescrever as propriedades específicas de índice da configuração, como `layer_types` ou `mtp_layer_types`, para criar as camadas mtp corretas e evitar problemas de indexação nas camadas (pois as camadas MTP reiniciam a indexação das camadas em 0).

#### get_text_config[[transformers.PreTrainedConfig.get_text_config]]

```python
get_text_config(decoder = None, encoder = None)
```

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

**Parâmetros:**

decoder (`Optional[bool]`, *opcional*) : Se definido como `True`, busca apenas nomes de configurações de decodificador.

encoder (`Optional[bool]`, *opcional*) : Se definido como `True`, busca apenas nomes de configuração do codificador.

Retorna a configuração de texto relacionada à entrada de texto (encoder) ou à saída de texto (decoder) do modelo. Os argumentos de entrada `decoder` e `encoder` podem ser usados para especificar em qual extremidade do modelo estamos interessados, o que é útil em modelos que possuem tanto a modalidade de entrada de texto quanto a de saída de texto.

Há três possíveis resultados ao usar este método:
1. Na maioria dos modelos, ele retorna a própria instância de configuração original.
2. Em modelos compostos mais recentes (2024+), ele retorna a seção de texto da configuração, que está aninhada sob um conjunto de nomes válidos.
3. Em modelos compostos mais antigos (2023-), ele descarta os parâmetros apenas de decodificador quando `encoder=True` e vice-versa.

#### is_custom_code[[transformers.PreTrainedConfig.is_custom_code]]

```python
is_custom_code()
```

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

Indica se a configuração 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.PreTrainedConfig.is_remote_code]]

```python
is_remote_code()
```

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

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

#### register_for_auto_class[[transformers.PreTrainedConfig.register_for_auto_class]]

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

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

**Parâmetros:**

auto_class (`str` ou `type`, *opcional*, padrão `"AutoConfig"`) : A classe auto com a qual registrar esta nova configuração.

Registre esta classe com uma classe auto específica. Isso deve ser usado apenas para configurações personalizadas, pois as da biblioteca já estão mapeadas com `AutoConfig`.

#### save_pretrained[[transformers.PreTrainedConfig.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, push_to_hub: bool = False, **kwargs)
```

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

**Parâmetros:**

save_directory (`str` ou `os.PathLike`) : Diretório onde o arquivo JSON de configuração será salvo (será criado se não existir).

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

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 objeto de configuração no diretório `save_directory` para que ele possa ser recarregado usando o método de classe [from_pretrained()](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained).

#### to_dict[[transformers.PreTrainedConfig.to_dict]]

```python
to_dict()
```

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

**Retorna:** `dict[str, Any]`

Dicionário de todos os atributos que compõem esta instância de configuração.

Serializa esta instância em um dicionário Python.

#### to_diff_dict[[transformers.PreTrainedConfig.to_diff_dict]]

```python
to_diff_dict()
```

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

**Retorna:** dict[str, Any]

Dicionário de todos os atributos que compõem esta instância de configuração.

Remove todos os atributos da configuração que correspondem aos atributos padrão da configuração, para melhorar a legibilidade, mantendo sempre o atributo `config` da classe. Serializa para um dicionário Python.

#### to_json_file[[transformers.PreTrainedConfig.to_json_file]]

```python
to_json_file(json_file_path: str | os.PathLike, use_diff: bool = True)
```

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

**Parâmetros:**

json_file_path (`str` ou `os.PathLike`) : Caminho para o arquivo JSON em que os parâmetros desta instância de configuração serão salvos.

use_diff (`bool`, *opcional*, padrão `True`) : Se definido como `True`, apenas a diferença entre a instância de configuração e o padrão `PreTrainedConfig()` é serializada para o arquivo JSON.

Salve esta instância em um arquivo JSON.

#### to_json_string[[transformers.PreTrainedConfig.to_json_string]]

```python
to_json_string(use_diff: bool = True)
```

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

**Parâmetros:**

use_diff (`bool`, *opcional*, padrão `True`) : Se definido como `True`, apenas a diferença entre a instância de configuração e o padrão `PreTrainedConfig()` é serializada para uma string JSON.

**Retorna:** `str`

String contendo todos os atributos que compõem esta instância de configuração em formato JSON.

Serializa esta instância em uma string JSON.

#### atualizar[[transformers.PreTrainedConfig.update]]

```python
update(config_dict: dict[str, Any])
```

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

**Parâmetros:**

config_dict (`dict[str, Any]`) : Dicionário de atributos que devem ser atualizados para esta classe.

Atualiza os atributos desta classe com os atributos de `config_dict`.

#### update_from_string[[transformers.PreTrainedConfig.update_from_string]]

```python
update_from_string(update_str: str)
```

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

**Parâmetros:**

update_str (`str`) : String com os atributos que devem ser atualizados para esta classe.

Atualiza os atributos desta classe com os atributos de `update_str`.

O formato esperado é ints, floats e strings como estão, e para booleans use `true` ou `false`. Por exemplo: "n_embd=10,resid_pdrop=0.2,scale_attn_weights=false,summary_type=cls_index"

As chaves a serem alteradas devem já existir no objeto de configuração.

#### validate[[transformers.PreTrainedConfig.validate]]

```python
validate()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/huggingface_hub/dataclasses.py#L247)

Execute os validadores de classe na instância.

#### validate_architecture[[transformers.PreTrainedConfig.validate_architecture]]

```python
validate_architecture()
```

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

Parte da validação habilitada por `@strict`. Valida a arquitetura da configuração.

#### validate_layer_type[[transformers.PreTrainedConfig.validate_layer_type]]

```python
validate_layer_type()
```

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

Verifique se `mlp_layer_types` e `layer_types` estão definidos corretamente.

#### validate_token_ids[[transformers.PreTrainedConfig.validate_token_ids]]

```python
validate_token_ids()
```

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

Parte da validação impulsionada por `@strict`. Valida o conteúdo dos tokens especiais.