# Configuración

La clase base [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) implementa los métodos comunes para cargar o guardar una configuración desde un archivo o directorio local, o desde la configuración de un modelo preentrenado proporcionado por la biblioteca (descargada del repositorio AWS S3 de HuggingFace).

Cada clase de configuración derivada implementa atributos específicos del modelo. Los atributos comunes presentes en todas las clases de configuración son: `hidden_size`, `num_attention_heads` y `num_hidden_layers`. Los modelos de texto implementan además: `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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L299)

**Parámetros:**

name_or_path (`str`, *opcional*, valor predeterminado `""`) : Almacena la cadena que se pasó a [PreTrainedModel.from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) como `pretrained_model_name_or_path` si la configuración se creó con dicho método.

output_hidden_states (`bool`, *opcional*, valor predeterminado `False`) : Indica si el modelo debe devolver todos los hidden-states.

output_attentions (`bool`, *opcional*, valor predeterminado `False`) : Indica si el modelo debe devolver todas las atenciones.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo debe devolver un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

is_encoder_decoder (`bool`, *opcional*, valor predeterminado `False`) : Indica si el modelo se utiliza como codificador/decodificador o no.

chunk_size_feed_forward (`int`, *opcional*, valor predeterminado `0`) : El tamaño de bloque de todas las capas feed forward en los bloques de atención residual. Un tamaño de bloque de `0` significa que la capa feed forward no se divide en bloques. Un tamaño de bloque de n significa que la capa feed forward procesa `n` < sequence_length embeddings a la vez. Para obtener más información sobre la división en bloques de las capas feed forward, consulte [¿Cómo funciona la división en bloques de las capas feed forward?](../glossary.html#feed-forward-chunking).

per_layer_config (`dict[int | str, dict[str, Any]]`, *opcional*) : Un mapeo disperso de índices de capa a sobrescrituras de atributos de configuración. Cada clave es un índice de capa y cada valor contiene los atributos que difieren de la configuración global para esa capa.

tie_last_hidden_states (`bool`, *opcional*) : Indica si `hidden_states[-1]` debe ser el `last_hidden_state` posterior a la normalización final, en lugar del estado oculto anterior a la normalización final. Si no se establece, se utiliza el valor predeterminado integrado del modelo.

**Parámetros para tareas de ajuste fino:**

architectures (`list[str]`, *opcional*) : Arquitecturas de modelo que se pueden utilizar con los pesos preentrenados del modelo.

id2label (`dict[int, str]`, *opcional*) : Un mapa de índice (por ejemplo, índice de predicción o índice de destino) a etiqueta.

label2id (`dict[str, int]`, *opcional*) : Un mapa de etiqueta a índice para el modelo.

num_labels (`int`, *opcional*) : Número de etiquetas a utilizar en la última capa añadida al modelo, típicamente para una tarea de clasificación.

problem_type (`str`, *opcional*) : Tipo de problema para los modelos `XxxForSequenceClassification`. Puede ser `"regression"`, `"single_label_classification"` o `"multi_label_classification"`.

**Parámetros específicos de PyTorch:**

dtype (`str`, *opcional*) : El `dtype` de los pesos. Este atributo se puede utilizar para inicializar el modelo con un `dtype` no predeterminado (que normalmente es `float32`) y, de este modo, permitir una asignación de almacenamiento óptima. Por ejemplo, si el modelo guardado es `float16`, idealmente queremos volver a cargarlo utilizando la cantidad mínima de memoria necesaria para cargar pesos `float16`.

Clase base para todas las clases de configuración. Gestiona algunos parámetros comunes a las configuraciones de todos los modelos, así como métodos para cargar, descargar y guardar configuraciones.

Un archivo de configuración se puede cargar y guardar en el disco. Cargar el archivo de configuración y usarlo para inicializar un modelo **no** carga los pesos del modelo. Solo afecta la configuración del modelo.

Atributos de clase (sobreescritos por las clases derivadas):

- **model_type** (`str`) -- Un identificador del tipo de modelo, serializado en el archivo JSON y utilizado para recrear el objeto correcto en [AutoConfig](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoConfig).
- **attribute_map** (`dict[str, str]`) -- Un diccionario que mapea los nombres de atributos específicos del modelo a la nomenclatura estandarizada de los atributos.
- **base_model_tp_plan** (`dict[str, Any]`) -- Un diccionario que mapea los FQN de los submódulos de un modelo base a un plan de paralelismo de tensores aplicado al submódulo cuando se llama a `model.tensor_parallel`.
- **base_model_fsdp_plan** (`dict[Any, str]`) -- Un diccionario que asigna a los submódulos de un modelo base una estrategia de particionamiento de FSDP2 (p. ej. `"free_full_weight"` / `"keep_full_weight"`). Las claves pueden ser rutas de módulo con comodines (p. ej. `"layers.*"`) o tuplas de rutas (agrupadas en una única llamada a `fully_shard`).
- **base_model_pp_plan** (`dict[str, tuple[list[str]]]`) -- Un diccionario que asigna a los submódulos de un modelo base un plan de paralelismo de pipeline que permite a los usuarios colocar el submódulo en el dispositivo adecuado.

Atributos comunes (presentes en todas las subclases):

- **vocab_size** (`int`) -- El número de tokens en el vocabulario, que también es la primera dimensión de la matriz de embeddings (este atributo puede no estar presente en modelos que no tienen una modalidad de texto, como ViT).
- **hidden_size** (`int`) -- El tamaño oculto del modelo.
- **num_attention_heads** (`int`) -- El número de cabezas de atención utilizadas en las capas de atención multi-cabeza del modelo.
- **num_hidden_layers** (`int`) -- El número de bloques en el modelo.

Establecer parámetros para la generación de secuencias en la configuración del modelo está en desuso. Por compatibilidad hacia atrás, la carga de algunos de ellos seguirá siendo posible, pero intentar sobrescribirlos lanzará una excepción: debe establecerlos en un [~transformers.GenerationConfig]. Consulte la documentación de [~transformers.GenerationConfig] para obtener más información sobre los parámetros individuales.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/hub.py#L822)

**Parámetros:**

repo_id (`str`) : El nombre del repositorio al que deseas enviar tu configuración. Debe incluir el nombre de tu organización al enviar a una organización determinada.

commit_message (`str`, *opcional*) : Mensaje para el commit al hacer push. El valor predeterminado es `"Upload config"`.

commit_description (`str`, *opcional*) : La descripción del commit que se creará

private (`bool`, *opcional*) : Si se debe hacer el repositorio privado. Si es `None` (valor predeterminado), el repositorio será público a menos que el valor predeterminado de la organización sea privado. Este valor se ignora si el repositorio ya existe.

token (`bool` o `str`, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es `True` (valor predeterminado), se usará el token generado al ejecutar `hf auth login` (guardado en `~/.huggingface`).

revision (`str`, *opcional*) : Rama a la que se enviarán los archivos subidos.

create_pr (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe crear una PR con los archivos subidos o realizar el commit directamente.

max_shard_size (`int` o `str`, *opcional*, valor predeterminado `"50GB"`) : Solo aplicable a modelos. El tamaño máximo de un checkpoint antes de que se divida en fragmentos. Los fragmentos del checkpoint tendrán cada uno un tamaño inferior a este valor. Si se expresa como una cadena, debe consistir en dígitos seguidos de una unidad (como `"5MB"`).

tags (`list[str]`, *opcional*) : Lista de etiquetas para publicar en el Hub.

Sube el archivo de configuración al 🤗 Model Hub.

Ejemplos:

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1474)

Obtiene los valores predeterminados de cada campo anotado en un dataclass, utilizado para guardar el diff-dict. Para las configuraciones creadas en v4 con un `__init__` personalizado, devolverá un diccionario vacío, por lo que se guardarán todas las claves de `self.__dict__`. Para las configuraciones más recientes, devolverá las claves que tienen valores predeterminados declarados como campos, en lugar de en `__post_init__`, lo que filtra únicamente estos campos específicos del archivo json serializado.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1395)

Comprueba si el diccionario pasado y sus diccionios anidados tienen una clave *dtype* y, si no es None, convierte torch.dtype en una cadena que contiene solo el tipo. Por ejemplo, `torch.float32` se convierte en la cadena *"float32"*, que luego puede almacenarse en formato json.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1054)

**Parámetros:**

config_dict (`dict[str, Any]`) : Diccionario que se utilizará para instanciar el objeto de configuración. Dicho diccionario puede obtenerse de un punto de control preentrenado mediante el método [get_config_dict()](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig.get_config_dict).

kwargs (`dict[str, Any]`) : Parámetros adicionales a partir de los cuales se inicializa el objeto de configuración.

**Devuelve:** [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig)

El objeto de configuración instanciado a partir de esos parámetros.

Instancia un [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) a partir de un diccionario de Python de parámetros.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1115)

**Parámetros:**

json_file (`str` o `os.PathLike`) : Ruta al archivo JSON que contiene los parámetros.

**Devuelve:** [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig)

El objeto de configuración instanciado a partir de ese archivo JSON.

Instancia un [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) a partir de la ruta a un archivo 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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L797)

**Parámetros:**

pretrained_model_name_or_path (`str` or `os.PathLike`) : This can be either:  - a string, the *model id* of a pretrained model configuration hosted inside a model repo on huggingface.co. - a path to a *directory* containing a configuration file saved using the [save_pretrained()](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig.save_pretrained) method, e.g., `./my_model_directory/`. - a path to a saved configuration JSON *file*, e.g., `./my_model_directory/configuration.json`.

cache_dir (`str` o `os.PathLike`, *opcional*) : Ruta a un directorio en el que se debe almacenar en caché la configuración de un modelo preentrenado descargado si no se debe usar la caché estándar.

force_download (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe forzar la (re)descarga de los archivos de configuración y sobrescribir las versiones en caché si existen.

proxies (`dict[str, str]`, *opcional*) : Un diccionario de servidores proxy a utilizar por protocolo o punto de acceso, p. ej., `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}.` Los proxies se utilizan en cada solicitud.

token (`str` o `bool`, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es `True`, o no se especifica, se usará el token generado al ejecutar `hf auth login` (almacenado en `~/.huggingface`).

revision (`str`, *opcional*, valor predeterminado `"main"`) : La versión específica del modelo que se va a utilizar. Puede ser el nombre de una rama, el nombre de una etiqueta o un id de commit, ya que utilizamos un sistema basado en git para almacenar modelos y otros artefactos en huggingface.co, por lo que `revision` puede ser cualquier identificador permitido por git.    Para probar una pull request que hayas realizado en el Hub, puedes pasar `revision="refs/pr/<pr_number>"`.

return_unused_kwargs (`bool`, *opcional*, valor predeterminado `False`) : Si es `False`, esta función devuelve solo el objeto de configuración final. Si es `True`, esta función devuelve una `Tuple(config, unused_kwargs)` donde *unused_kwargs* es un diccionario que consiste en pares clave/valor cuyas claves no son atributos de configuración: es decir, la parte de `kwargs` que no se ha utilizado para actualizar `config` y que se ignora de lo contrario.

subfolder (`str`, *opcional*, valor predeterminado `""`) : Si los archivos relevantes se encuentran en una subcarpeta del repositorio del modelo en huggingface.co, puede especificar aquí el nombre de la carpeta.

kwargs (`dict[str, Any]`, *opcional*) : Los valores en kwargs de cualquier clave que sea un atributo de configuración se utilizarán para reemplazar los valores cargados. El comportamiento respecto a los pares clave/valor cuyas claves *no* son atributos de configuración se controla mediante el parámetro de palabra clave `return_unused_kwargs`.

**Devuelve:** [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig)

El objeto de configuración instanciado a partir de este modelo preentrenado.

Instanciar un [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) (o una clase derivada) a partir de la configuración de un modelo preentrenado.

Ejemplos:

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L909)

**Parámetros:**

pretrained_model_name_or_path (`str` o `os.PathLike`) : El identificador del punto de control preentrenado del que queremos obtener el diccionario de parámetros.

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

El diccionario (o diccionarios) que se utilizará para instanciar el objeto de configuración.

A partir de un `pretrained_model_name_or_path`, resuelve a un diccionario de parámetros, para ser utilizado en la instanciación de un [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) mediante `from_dict`.

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

```python
get_mtp_config()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1596)

Devuelve la configuración de texto mtp que se utilizará para crear el modelo MTP. Dado que las capas MTP se crean instanciando las mismas clases que el modelo principal, es necesario sobrescribir las propiedades específicas del índice de la configuración, como `layer_types` o `mtp_layer_types`, para crear las capas mtp correctas y evitar problemas de indexación en las capas (ya que las capas MTP reinician la indexación de las capas en 0).

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1519)

**Parámetros:**

decoder (`Optional[bool]`, *opcional*) : Si se establece en `True`, solo se buscarán nombres de configuración del decodificador.

encoder (`Optional[bool]`, *opcional*) : Si se establece en `True`, solo se buscarán nombres de configuración del codificador.

Devuelve la configuración de texto relacionada con la entrada de texto (codificador) o la salida de texto (decodificador) del modelo. Los argumentos de entrada `decoder` y `encoder` se pueden utilizar para especificar en qué extremo del modelo estamos interesados, lo cual es útil en modelos que tienen tanto modalidades de entrada como de salida de texto.

Hay tres posibles resultados al usar este método:
1. En la mayoría de los modelos, devuelve la instancia de configuración original.
2. En los modelos compuestos más recientes (2024+), devuelve la sección de texto de la configuración, que está anidada bajo un conjunto de nombres válidos.
3. En los modelos compuestos más antiguos (2023-), descarta los parámetros solo de decodificador cuando `encoder=True` y viceversa.

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

```python
is_custom_code()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1468)

Indica si la configuración actual es de código personalizado, es decir, si el código se cargó desde el hub o se definió en un módulo o sesión específico del usuario.

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

```python
is_remote_code()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1462)

Devuelve si la configuración actual es código personalizado, es decir, código cargado desde el hub, o una clase que acabamos de registrar mediante `register_for_auto_class`.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1440)

**Parámetros:**

auto_class (`str` o `type`, *opcional*, valor predeterminado `"AutoConfig"`) : La clase auto con la que registrar esta nueva configuración.

Registra esta clase con una clase auto dada. Esto solo debe usarse para configuraciones personalizadas, ya que las de la biblioteca ya están mapeadas con `AutoConfig`.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L735)

**Parámetros:**

save_directory (`str` o `os.PathLike`) : Directorio donde se guardará el archivo JSON de configuración (se creará si no existe).

push_to_hub (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe subir el modelo al Hugging Face model hub después de guardarlo. Puede especificar el repositorio al que desea subirlo con `repo_id` (por defecto, se usará el nombre de `save_directory` en su espacio de nombres).

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan al método [push_to_hub()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Guarde un objeto de configuración en el directorio `save_directory` para que pueda recargarse mediante el método de clase [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained).

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

```python
to_dict()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1261)

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

Diccionario de todos los atributos que componen esta instancia de configuración.

Serializa esta instancia en un diccionario de Python.

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

```python
to_diff_dict()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1199)

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

Diccionario de todos los atributos que componen esta instancia de configuración.

Elimina todos los atributos de la configuración que corresponden a los atributos de la configuración predeterminada para mejorar la legibilidad, mientras que siempre conserva el atributo `config` de la clase. Serializa a un diccionario de Python.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1333)

**Parámetros:**

json_file_path (`str` o `os.PathLike`) : Ruta al archivo JSON en el que se guardarán los parámetros de esta instancia de configuración.

use_diff (`bool`, *opcional*, valor predeterminado `True`) : Si se establece en `True`, solo se serializa a un archivo JSON la diferencia entre la instancia de configuración y la configuración predeterminada `PreTrainedConfig()`.

Guarde esta instancia en un archivo JSON.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1311)

**Parámetros:**

use_diff (`bool`, *opcional*, valor predeterminado `True`) : Si se establece en `True`, solo se serializa a una cadena JSON la diferencia entre la instancia de configuración y la configuración predeterminada `PreTrainedConfig()`.

**Devuelve:** `str`

Cadena que contiene todos los atributos que componen esta instancia de configuración en formato JSON.

Serializa esta instancia en una cadena JSON.

#### actualizar[[transformers.PreTrainedConfig.update]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1347)

**Parámetros:**

config_dict (`dict[str, Any]`) : Diccionario de atributos que deben actualizarse para esta clase.

Actualiza los atributos de esta clase con los atributos de `config_dict`.

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L1357)

**Parámetros:**

update_str (`str`) : Cadena con los atributos que deben actualizarse para esta clase.

Actualiza los atributos de esta clase con los atributos de `update_str`.

El formato esperado es ints, floats y strings tal cual, y para los booleanos se usa `true` o `false`. Por ejemplo: "n_embd=10,resid_pdrop=0.2,scale_attn_weights=false,summary_type=cls_index"

Las claves que se van a cambiar deben existir ya en el objeto de configuración.

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

```python
validate()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/huggingface_hub/dataclasses.py#L247)

Ejecuta los validadores de clase en la instancia.

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

```python
validate_architecture()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L670)

Parte de la validación impulsada por `@strict`. Valida la arquitectura de la configuración.

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

```python
validate_layer_type()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L703)

Comprueba que `mlp_layer_types` y `layer_types` están definidos correctamente.

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

```python
validate_token_ids()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/configuration_utils.py#L687)

Parte de la validación impulsada por `@strict`. Valida el contenido de los tokens especiales.