# Modelos

La clase base [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel) implementa los métodos comunes para cargar/guardar un modelo desde un archivo o directorio local, o desde una configuración de modelo preentrenado proporcionada por la biblioteca (descargada del Hub de HuggingFace).

[PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel) también implementa algunos métodos comunes a todos los modelos para:

- redimensionar las incrustaciones de tokens de entrada cuando se añaden nuevos tokens al vocabulario

Los otros métodos comunes a cada modelo están definidos en [ModuleUtilsMixin](/docs/transformers/main/es/main_classes/model#transformers.modeling_utils.ModuleUtilsMixin) y [GenerationMixin](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationMixin).

## PreTrainedModel[[transformers.PreTrainedModel]]

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

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

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

Clase base para todos los modelos.

[PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel) se encarga de almacenar la configuración de los modelos y gestiona los métodos para cargar, descargar y guardar modelos, así como algunos métodos comunes a todos los modelos:

- redimensionar los embeddings de entrada

Atributos de clase (sobreescritos por las clases derivadas):

- **config_class** ([PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig)) -- Una subclase de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para usar como clase de configuración de esta arquitectura de modelo.
- **base_model_prefix** (`str`) -- Una cadena que indica el atributo asociado al modelo base en las clases derivadas de la misma arquitectura que añaden módulos sobre el modelo base.
- **main_input_name** (`str`) -- El nombre de la entrada principal del modelo (a menudo `input_ids` para modelos de NLP, `pixel_values` para modelos de visión y `input_values` para modelos de voz).
- **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)
```

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

**Parámetros:**

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

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

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 del modelo al 🤗 Model Hub.

Ejemplos:

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

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

Desactiva el checkpointing de activaciones para el modelo actual.

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

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

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

**Parámetros:**

every_n_layers (`int`, *opcional*, valor predeterminado 1) : Realiza un checkpoint solo en cada capa decodificadora `every_n_layers`, dejando que el resto conserve sus activaciones. `1` realiza un checkpoint en cada capa, que es el comportamiento habitual de todo o nada. Valores más grandes intercambian memoria por velocidad, lo cual vale la pena siempre que la memoria liberada por el checkpoint completo vaya a quedar sin uso.

offload (`bool`, *opcional*, valor predeterminado `False`) : Mantener las activaciones guardadas para el recálculo en memoria de host fijada (pinned) en lugar de en el acelerador. Esto libera `layers x sequence x hidden` bytes de memoria del dispositivo, lo cual es lo que predomina con longitudes de secuencia largas, y tiene un coste de una copia de dispositivo a host en la propagación hacia adelante y una copia de host a dispositivo en la propagación hacia atrás. Ambas copias se ejecutan en el stream de cómputo, por lo que el paso se vuelve más lento.

activation_checkpointing_kwargs (dict, *opcional*) : Argumentos de palabra clave adicionales que se pasan a la función `torch.utils.checkpoint.checkpoint`.

Activa el checkpointing de activaciones para el modelo actual.

Pasamos el método `__call__` de los módulos en lugar de `forward` porque `__call__` adjunta todos los hooks del 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)
```

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

**Parámetros:**

tags (`Union[list[str], str]`) : Las etiquetas deseadas para inyectar en el modelo

Añade etiquetas personalizadas al modelo que se sube al Hugging Face Hub. No sobrescribirá las etiquetas existentes del modelo.

Ejemplos:

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

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

**Devuelve:** `bool`

Si este modelo puede generar secuencias con `.generate()`.

Indica si este modelo puede generar secuencias con `.generate()`, desde `GenerationMixin` o uno con una interfaz similar.

Por debajo, en las clases donde esta función devuelve True, se activan algunos cambios específicos de la generación: por ejemplo, la instancia del modelo tendrá un atributo `generation_config` con valor.

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

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

Un valor simulado para una ruta con puntos (p. ej., `torch.float32`): las cadenas de acceso a atributos y las llamadas se comportan como decoradores de paso, `repr` es la ruta con puntos, y su uso como clase base sustituye una base de `type` simple (PEP 560 `__mro_entries__`), de modo que las subclases reales conservan un metaclass normal y `inspect.signature` lee su `__init__` real en lugar del de un simulacro.

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

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

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

Descomprimir el modelo si ha sido cuantizado mediante un método de cuantización que admita la descompresión.

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

```python
disable_input_require_grads()
```

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

Elimina el `_require_grads_hook`.

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

```python
enable_input_require_grads()
```

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

Habilita los gradientes para los embeddings de entrada. Esto es útil para ajustar los pesos del adaptador mientras se mantienen fijos los pesos del modelo.

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

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

**Parámetros:**

pretrained_model_name_or_path (`str` o `os.PathLike`, *opcional*) : Puede ser:  - Una cadena, el *model id* de un modelo preentrenado alojado en un repositorio de modelos en huggingface.co. - Una ruta a un *directorio* que contiene los pesos del modelo guardados con [save_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.save_pretrained), por ejemplo, `./my_model_directory/`. Los directorios guardados con `save_pretrained(..., distributed_checkpoint=True)` se detectan y cargan con distributed checkpointing (DCP), preservando la malla y las ubicaciones actuales del modelo. Esto requiere `torch>=2.7` y la carga es estricta: cada clave del modelo debe estar presente en el checkpoint. - `None` si se proporciona tanto la configuración como el diccionario de estado (mediante los argumentos de palabra clave `config` y `state_dict`, respectivamente).

model_args (secuencia de argumentos posicionales, *opcional*) : Todos los argumentos posicionales restantes se pasarán al método `__init__` del modelo subyacente.

config (`Union[PreTrainedConfig, str, os.PathLike]`, *opcional*) : Puede ser:  - una instancia de una clase derivada de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig), - una cadena o ruta válida como entrada para [from_pretrained()](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained).  Configuración del modelo a utilizar en lugar de una configuración cargada automáticamente. La configuración se puede cargar automáticamente cuando:  - El modelo es un modelo proporcionado por la biblioteca (cargado con la cadena *model id* de un modelo preentrenado). - El modelo se guardó usando [save_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.save_pretrained) y se vuelve a cargar proporcionando el directorio de guardado. - El modelo se carga proporcionando un directorio local como `pretrained_model_name_or_path` y se encuentra un archivo JSON de configuración llamado *config.json* en el directorio.

state_dict (`dict[str, torch.Tensor]`, *opcional*) : Un diccionario de estado para usar en lugar de un diccionario de estado cargado desde un archivo de pesos guardados. Esta opción se puede usar si deseas crear un modelo a partir de una configuración preentrenada pero cargar tus propios pesos. En este caso, sin embargo, deberías comprobar si usar [save_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.save_pretrained) y [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) no es una opción más sencilla.

cache_dir (`Union[str, 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.

ignore_mismatched_sizes (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe lanzar un error si algunos de los pesos del punto de control no tienen el mismo tamaño que los pesos del modelo (por ejemplo, si se instancia un modelo con 10 etiquetas a partir de un punto de control con 3 etiquetas).

force_download (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe forzar la (re)descarga de los pesos del modelo y los archivos de configuración, reemplazando 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.

output_loading_info(`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver también un diccionario que contenga las claves faltantes, las claves inesperadas y los mensajes de error.

local_files_only(`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben buscar únicamente archivos locales (es decir, no intentar descargar el modelo).

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

attn_implementation (`str`, *opcional*) : La implementación de atención a utilizar en el modelo (si es relevante). Puede ser cualquiera de - `"eager"` (implementación manual de la atención) - `"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)). De forma predeterminada, si está disponible, se utilizará SDPA. En caso contrario, la implementación predeterminada es la manual `"eager"`.  Acepta referencias a kernels de HF en el formato: /[@][:]  -  y  son cualquier secuencia que no contenga "/" ni ":". - "@" es opcional (rama, etiqueta o commit-ish), por ejemplo, "@main", "@v1.2.0", "@abc123". - ":" es opcional y selecciona una función dentro del repositorio del kernel. - Ambas opciones pueden aparecer juntas y solo en este orden: primero @revision, luego :kernel_name. - Se permite intencionalmente un prefijo inicial "|" (por ejemplo, "flash|...") porque el código lo elimina antes de cargar; '|' no está excluido en las clases de caracteres aquí.  Ejemplos que coinciden: "org/model" "org/model@main" "org/model:custom_kernel" "org/model@v1.2.3:custom_kernel"

experts_implementation (`str`, *opcional*) : La implementación de expertos a utilizar en el modelo (si es relevante). Puede ser cualquiera de:  - `"eager"` (implementación secuencial de las multiplicaciones de matrices de expertos). - `"batched_mm"` (utilizando [`torch.bmm`](https://pytorch.org/docs/stable/generated/torch.bmm.html)). - `"grouped_mm"` (utilizando [`torch.nn.functional.grouped_mm`](https://docs.pytorch.org/docs/main/generated/torch.nn.functional.grouped_mm.html)).  De forma predeterminada, si el modelo lo admite, se utilizará `"grouped_mm"`. En caso contrario, la implementación predeterminada es la manual `"eager"`.

**Parámetros para la inferencia de modelos grandes:**

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Anula el valor predeterminado de `torch_dtype` y carga el modelo con un `dtype` específico. Las distintas opciones son:  1. `torch.float16` o `torch.bfloat16` o `torch.float`: carga el modelo con un `dtype` especificado, ignorando el `config.dtype` del modelo si existe. Si no se especifica, el modelo se cargará en `torch.float` (fp32).  2. `"auto"` - Se intentará utilizar una entrada de `dtype` o `torch_dtype` en el archivo `config.json` del modelo. Si no se encuentra esta entrada, se comprobará a continuación el `dtype` del primer peso del checkpoint que sea de un tipo de punto flotante y se usará ese como `dtype`. Esto cargará el modelo usando el `dtype` en el que se guardó al final del entrenamiento. No se puede usar como indicador de cómo se entrenó el modelo, ya que podría haberse entrenado con uno de los dtypes de media precisión, pero guardarse en fp32.  3. Una cadena que sea un `torch.dtype` válido. Por ejemplo, "float32" carga el modelo en `torch.float32`, "float16" lo carga en `torch.float16`, etc.    Para algunos modelos, el `dtype` en el que se entrenaron es desconocido; puede intentar consultar el paper del modelo o ponerse en contacto con los autores y pedirles que añadan esta información a la tarjeta del modelo e inserten la entrada de `dtype` o `torch_dtype` en `config.json` en el hub.

device_map (`str` o `dict[str, Union[int, str, torch.device]]` o `int` o `torch.device`, *opcional*) : Un mapa que especifica en qué dispositivo debe ir cada submódulo. No es necesario detallarlo para cada nombre de parámetro/búfer; una vez que un nombre de módulo está incluido, todos sus submódulos se enviarán al mismo dispositivo. Si solo se pasa el dispositivo (*p. ej.*, `"cpu"`, `"cuda:1"`, `"mps"` o un rango ordinal de GPU como `1`) en el que se asignará el modelo, el mapa de dispositivos asignará el modelo completo a este dispositivo. Pasar `device_map = 0` significa colocar el modelo completo en la GPU 0. Para que Accelerate calcule automáticamente el `device_map` más optimizado, establezca `device_map="auto"`. Para obtener más información sobre cada opción, consulte [el diseño de un mapa de dispositivos](https://hf.co/docs/accelerate/main/en/usage_guides/big_modeling#designing-a-device-map).

max_memory (`Dict`, *opcional*) : Un diccionario de identificador de dispositivo a memoria máxima si se usa `device_map`. Si no se establece, se usará por defecto la memoria máxima disponible para cada GPU y la RAM de CPU disponible.

distributed_config ([DistributedConfig](/docs/transformers/main/es/expert_parallelism#transformers.DistributedConfig), *opcional*) : Configuración para la carga distribuida nativa con paralelismo de tensores o FSDP2. Pasa `DistributedConfig(tp_size=N)` para usar el plan de paralelismo de tensores predefinido de un modelo, `DistributedConfig(tp_plan=...)` para especificar un plan de paralelismo de tensores, o `DistributedConfig(fsdp_size=N)` para FSDP2. Requiere `torchrun` y un grupo de procesos inicializado cuando `tp_size > 1` o `fsdp_size > 1`. Es mutuamente excluyente con `device_map`.

device_mesh (`torch.distributed.DeviceMesh`, *opcional*) : Una malla de dispositivos de torch. Si no se proporciona, se usará el tamaño del mundo por defecto. Por ahora, solo se utiliza para la paralelización de tensores. Si se proporciona, debe contener una dimensión llamada `"tp"` en caso de que sea de más de 1 dimensión; esta dimensión se utilizará para la paralelización de tensores.

offload_folder (`str` o `os.PathLike`, *opcional*) : Si `device_map` contiene algún valor `"disk"`, la carpeta donde se descargan los pesos.

offload_buffers (`bool`, *opcional*) : Si se deben descargar o no los búferes con los parámetros del modelo.

quantization_config (`Union[QuantizationConfigMixin,Dict]`, *opcional*) : Un diccionario de parámetros de configuración o un objeto QuantizationConfigMixin para la cuantización (p. ej., bitsandbytes, gptq).

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.

variant (`str`, *opcional*) : Si se especifica, carga los pesos desde el nombre de archivo `variant`, *p. ej.* pytorch_model..bin.

use_safetensors (`bool`, *opcional*, valor predeterminado `None`) : Indica si se deben usar puntos de control de `safetensors`. El valor predeterminado es `None`. Si no se especifica y `safetensors` no está instalado, se establecerá en `False`.

weights_only (`bool`, *opcional*, valor predeterminado `True`) : Indica si el unpickler debe estar restringido a cargar solo tensores, tipos primitivos, diccionarios y cualquier tipo añadido mediante torch.serialization.add_safe_globals(). Cuando se establece en False, se pueden cargar pesos de subclases de tensores envueltos.

disable_mmap (`bool`, *opcional*) : Si se debe deshabilitar el mapeo de memoria al cargar puntos de control de safetensors. Cuando es `None` (valor predeterminado), se detecta automáticamente como `True` cuando el punto de control se encuentra en un sistema de archivos FUSE `hf-mount` (utilizado por HF Spaces/Endpoints), donde mmap + fallas de página paralelas pueden provocar un bloqueo. Cuando es `True`, los archivos se leen por completo en memoria y se analizan con `safetensors.torch.load`. Cuando es `False`, siempre se utiliza el cargador con mapeo de memoria predeterminado.

fusion_config (`dict[str, bool | dict[str, Any]]`, *opcional*) : Configuración de fusión opcional que se aplica antes de la instanciación del modelo. Cada clave habilita una familia de fusión y su valor puede ser `True` para habilitar esa fusión con las opciones predeterminadas, o un diccionario de opciones específicas de la familia. Por ejemplo, `{"patch_embeddings": True}` habilita la fusión de patch embedding. Esto solo debe usarse como una optimización de inferencia, ya que puede cambiar ligeramente las salidas. Si se omite, `from_pretrained()` recurre a `config.fusion_config` cuando está disponible. Consulte la guía de mapeo de fusión en `docs/source/en/fusion_mapping.md` para obtener más detalles.

key_mapping (`dict[str, str], *opcional*) : Un posible mapeo de los nombres de los pesos si se utiliza un modelo del Hub que es compatible con una arquitectura de Transformers, pero que no se ha convertido en consecuencia.

kwargs (diccionario restante de argumentos de palabra clave, *opcional*) : Se puede utilizar para actualizar el objeto de configuración (después de que se haya cargado) e iniciar el modelo (p. ej., `output_attentions=True`). Su comportamiento varía según se proporcione una `config` o se cargue automáticamente:  - Si se proporciona una configuración con `config`, `**kwargs` se pasará directamente al método `__init__` del modelo subyacente (se asume que todas las actualizaciones relevantes de la configuración ya se han realizado) - Si no se proporciona una configuración, `kwargs` se pasará primero a la función de inicialización de la clase de configuración ([from_pretrained()](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained)). Cada clave de `kwargs` que corresponda a un atributo de configuración se utilizará para sobrescribir dicho atributo con el valor de `kwargs` proporcionado. Las claves restantes que no correspondan a ningún atributo de configuración se pasarán a la función `__init__` del modelo subyacente.

Instanciar un modelo de pytorch preentrenado a partir de una configuración de modelo preentrenado.

El modelo se establece en modo de evaluación de forma predeterminada mediante `model.eval()` (los módulos Dropout se desactivan). Para entrenar el modelo, primero debe volver a establecerlo en modo de entrenamiento con `model.train()`.

La advertencia *Weights from XXX not initialized from pretrained model* significa que los pesos de XXX no provienen preentrenados junto con el resto del modelo. Corresponde a usted entrenar esos pesos con una tarea de ajuste fino de nivel inferior.

La advertencia *Weights from XXX not used in YYY* significa que la capa XXX no se utiliza en YYY, por lo que esos pesos se descartan.

Active el modo especial ["offline-mode"](https://huggingface.co/transformers/installation.html#offline-mode) para usar este método en un entorno con cortafuegos.

Ejemplos:

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

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

Devuelve una versión compilada con `torch.compile` de `self.__call__`. Esto es útil para elegir dinámicamente entre `forward` no compilado y compilado durante la inferencia, especialmente para alternar entre prefill (donde no se desea usar la versión compilada para evitar recalcular el grafo con nuevas formas) y decodificación iterativa (donde se buscan las mejoras de velocidad de la versión compilada con formas estáticas).

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

```python
get_decoder()
```

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

Búsqueda de mejor esfuerzo del módulo *decoder*.

Orden de intentos (cubre ~85 % de los usos actuales):

1. `self.decoder/self.language_model/self.text_model`
2. `self.base_model`                  (muchos envoltorios almacenan el decodificador aquí)
3. `self.base_model.get_decoder()`    (envolventes anidadas)
4. fallback: lanzar una excepción para los pocos modelos exóticos que requieren una regla a medida

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

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

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

Búsqueda con el mejor esfuerzo del módulo *encoder*. Si se proporciona el argumento `modality`, busca un codificador específico de la modalidad en los modelos multimodales (p. ej. "image_encoder"). Por defecto, la función devuelve el codificador de texto del modelo, si existe, y en caso contrario devuelve `self`.

Los valores posibles de `modality` son "image", "video" y "audio".

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

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

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

Devuelve las claves de pesos vinculados expandidos (en caso de que contengan módulos o patrones de expresiones regulares) solo para el modelo actual, o de forma recursiva para todos los submodelos si `all_submodels=True` (es decir, volverá a comprobar los valores de configuración de todos los submodelos).

Para casi todos los modelos, solo es necesario vincular los embeddings, por lo que el modelo tiene una propiedad interna `_tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"}`. En este caso, el mapeo ya está "expandido", es decir, ya contiene los parámetros completos, y esta función simplemente devolverá una copia de la propiedad. Para patrones más complejos, por ejemplo, para `DFineForObjectDetection`, tenemos el siguiente 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",
}
```

En este caso, la función busca todos los parámetros y buffers del modelo y coincide con todos los parámetros,

devolviendo lo siguiente:
```
{
    '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',
    ...
}
```

es decir, todos los parámetros que coinciden con las expresiones regulares y los patrones de módulos en `_tied_weights_keys`

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

```python
get_experts_implementation()
```

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

Devuelve la implementación de expertos de este modelo y sus submodelos, como un `dict` en el formato aceptado por `set_experts_implementation` (`""` para este modelo, y una entrada por cada sub_config). Esta es la contraparte de `set_experts_implementation`, por ejemplo, para tomar una instantánea de la implementación actual y restaurarla más tarde.

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

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

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

**Parámetros:**

return_buffers (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe incluir el tamaño de los tensores de buffer en el cálculo de la huella de memoria. Los buffers son tensores que no requieren gradientes y no están registrados como parámetros. Por ejemplo, la media y la desviación estándar en las capas de batch norm. Consulte: https://discuss.pytorch.org/t/what-pytorch-means-by-buffers/120266/2

Obtén la huella de memoria de un modelo. Esto devolverá la huella de memoria del modelo actual en bytes. Útil para medir la huella de memoria del modelo actual y diseñar algunas pruebas. Solución inspirada en las discusiones de 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)
```

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

Devuelve el parámetro o búfer indicado por `target` si existe; de lo contrario, lanza un error. Esta función combina `get_parameter()` y `get_buffer()` en una única función práctica. Si el destino es un atributo `_extra_state`, devolverá el estado adicional proporcionado por el módulo. Tenga en cuenta que solo funciona si `target` es una hoja del modelo.

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

```python
gradient_checkpointing_disable()
```

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

Alias obsoleto de [activation_checkpointing_disable()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.activation_checkpointing_disable), se eliminará en v6.

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

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

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

Alias obsoleto de [activation_checkpointing_enable()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.activation_checkpointing_enable), se eliminará en v6.

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

```python
init_weights()
```

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

Inicialice y vincule los pesos si es necesario. Si utiliza un `PreTrainedModel` personalizado, debe implementar la lógica de inicialización en `_init_weights`.

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

```python
initialize_weights()
```

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

Esto es equivalente a llamar a `self.apply(self._initialize_weights)`, pero maneja correctamente los modelos compuestos. Esta función despacha dinámicamente la función `init_weights` correcta a los módulos a medida que avanzamos en el grafo de módulos a lo largo de la recursión. Puede manejar un número arbitrario de submodelos. Sin ella, cada modelo compuesto tendría que recursar una segunda vez en todos los submodelos de forma explícita en el `_init_weights` más externo, lo cual es extremadamente propenso a errores e ineficiente.

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

```python
is_custom_code()
```

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

Indica si el modelo actual es código personalizado, es decir, si se cargó desde el hub o si está definido en un módulo o sesión específico del usuario.

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

```python
is_remote_code()
```

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

Devuelve si el modelo 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`.

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

```python
mark_tied_weights_as_initialized(loading_info)
```

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

Añade la bandera `_is_hf_initialized` a los parámetros que se vincularán, para evitar inicializarlos más adelante, ya que de todos modos se vincularán (se sobrescribirán). Esto es muy importante, ya que la mayoría de las incrustaciones están vinculadas y son parámetros enormes (los vocabularios suelen ser de 256k), por lo que ejecutar inicializaciones sobre ellos es muy costoso.

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

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

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

Similar a `named_buffers`, pero solo produce los no persistentes. Es útil, ya que no es del todo obvio saber si son persistentes o no.

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

```python
post_init()
```

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

Un método que se ejecuta al final de la inicialización de cada modelo de Transformers, para ejecutar código que requiere que los módulos del modelo estén correctamente inicializados (como la inicialización de pesos). También se utiliza para obtener todas las propiedades estáticas correctas (planes de paralelismo, tied_weights_keys, _keep_in_fp32_modules, etc.) de manera adecuada en el caso de modelos compuestos (es decir, el modelo de nivel superior debe conocer esas propiedades de sus hijos).

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

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

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

**Parámetros:**

auto_class (`str` o `type`, *opcional*, valor predeterminado `"AutoModel"`) : La clase auto con la que registrar este nuevo modelo.

Registra esta clase con una clase auto dada. Esto solo debe usarse para modelos personalizados, ya que los de la biblioteca ya están mapeados con una clase auto.

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

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

**Parámetros:**

new_num_tokens (`int`, *opcional*) : El nuevo número de tokens en la matriz de incrustación. Aumentar el tamaño añadirá vectores recién inicializados al final. Reducir el tamaño eliminará vectores desde el final. Si no se proporciona o es `None`, simplemente devuelve un puntero al módulo de tokens de entrada `torch.nn.Embedding` del modelo sin hacer nada.

pad_to_multiple_of (`int`, *opcional*) : Si se establece, rellenará la matriz de incrustaciones hasta un múltiplo del valor proporcionado. Si `new_num_tokens` se establece en `None`, simplemente rellenará la incrustación hasta un múltiplo de `pad_to_multiple_of`. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo `>= 7.5` (Volta), o en TPUs, que se benefician de que las longitudes de secuencia sean un múltiplo de 128. Para más detalles sobre esto, o ayuda para elegir el valor correcto para el redimensionado, consulte esta guía: https://docs.nvidia.com/deeplearning/performance/dl-performance-matrix-multiplication/index.html#requirements-tc

mean_resizing (`bool`) : Indica si se deben inicializar los embeddings añadidos a partir de una distribución normal multivariante que tenga la media y la covarianza de los embeddings anteriores, o si se deben inicializar con una distribución normal que tenga una media de cero y una desviación estándar igual a `config.initializer_range`. Establecer `mean_resizing` en `True` es útil al aumentar el tamaño de los embeddings de los modelos de lenguaje causales, ya que las probabilidades de los tokens generados no se verán afectadas por los embeddings añadidos, porque inicializar los nuevos embeddings con la media de los embeddings anteriores reducirá la divergencia de KL entre la probabilidad del siguiente token antes y después de añadir los nuevos embeddings. Consulte este artículo para obtener más información: https://nlp.stanford.edu/~johnhew/vocab-expansion.html

**Devuelve:** `torch.nn.Embedding`

Puntero al módulo de Embeddings de los tokens de entrada del modelo.

Redimensiona la matriz de incrustaciones de tokens de entrada del modelo si `new_num_tokens != config.vocab_size`.

Se encarga de vincular los pesos de las incrustaciones después, si la clase del modelo tiene un 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)
```

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

**Parámetros:**

save_directory (`str` o `os.PathLike`) : Directorio en el que se guardará. Se creará si no existe.

is_main_process (`bool`, *opcional*, valor predeterminado `True`) : Indica si el proceso que realiza esta llamada es el proceso principal o no. Útil en el entrenamiento distribuido, como con TPUs, cuando se necesita llamar a esta función en todos los procesos. En este caso, establezca `is_main_process=True` solo en el proceso principal para evitar condiciones de carrera.

state_dict (dict anidado de `torch.Tensor`) : El diccionario de estado del modelo a guardar. Por defecto, se usará `self.state_dict()`, pero se puede utilizar para guardar solo partes del modelo o si se necesitan precauciones especiales al recuperar el diccionario de estado de un modelo (como cuando se usa paralelismo de modelos).

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

max_shard_size (`int` o `str`, *opcional*, valor predeterminado `"50GB"`) : El tamaño máximo de un checkpoint antes de ser fragmentado. 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"`).    Si un solo peso del modelo es mayor que `max_shard_size`, se colocará en su propio fragmento de checkpoint, que será mayor que `max_shard_size`.

variant (`str`, *opcional*) : Si se especifica, los pesos se guardan en el formato model..safetensors.

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

save_peft_format (`bool`, *opcional*, valor predeterminado `True`) : Para la compatibilidad hacia atrás con la biblioteca PEFT, si los pesos de los adaptadores están unidos al modelo, todas las claves del state dict de los adaptadores deben tener `base_model.model` como prefijo. Los usuarios avanzados pueden deshabilitar este comportamiento estableciendo `save_peft_format` en `False`.

save_original_format (`bool`, *opcional*, valor predeterminado `True`) : Para la compatibilidad hacia atrás con las versiones anteriores de `transformers`, puedes guardar el punto de control con su mapeo inverso. El mapeo inverso debe existir incluso si el modelo se cargó desde un punto de control legacy None.

distributed_checkpoint (`bool`, *opcional*, valor predeterminado `False`) : Al guardar un modelo con particiones de FSDP o TP, escribe safetensors con checkpointing distribuido (DCP) en lugar de reunir primero los pesos en la CPU. Cada rank debe llamar a este método. Cuando es `False`, los pesos se reúnen en la CPU en el rank 0 mediante `gather_full_state_dict` antes de escribirlos. Solo está pensado para guardar y reanudar el entrenamiento; establécelo en `False` si deseas todas las funciones de `save_pretrained`. Con `push_to_hub=True`, el rank 0 consolida el checkpoint en un subdirectorio `consolidated/` y sube ese directorio. Requiere `torch>=2.7`.

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

Guarde un modelo y su archivo de configuración en un directorio para que pueda recargarse mediante el método de clase [from_pretrained()](/docs/transformers/main/es/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)
```

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

**Parámetros:**

attn_implementation (`str` o `dict`) : La implementación de atención que se establecerá para este modelo. Puede ser una `str`, en cuyo caso se asignará a todos los submodelos si es relevante, o un `dict` donde las claves son los nombres de los sub_configs, en cuyo caso cada submodelo asignará el valor correspondiente (a sí mismo y a todos los submodelos anidados en él). Un valor puede ser a su vez un `dict` en el mismo formato, para apuntar a los sub_configs de ese submodelo (como al inicializar una config con un `attn_implementation` dict anidado).

allow_all_kernels (`bool`, opcional) : Si se deben cargar kernels desde repositorios no verificados del hub, si `attn_implementation` es un kernel personalizado fuera del repositorio del hub `kernels-community`.

Establece el `attn_implementation` solicitado para este modelo.

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

```python
set_decoder(decoder)
```

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

Configurador simétrico. Replica la lógica de búsqueda utilizada en `get_decoder`.

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

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

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

Configurador simétrico. Replica la lógica de búsqueda utilizada en `get_encoder`.

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

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

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

**Parámetros:**

experts_implementation (`str` o `dict`) : La implementación de expertos que se establecerá para este modelo. Puede ser una `str`, en cuyo caso se distribuirá a todos los submodelos si es relevante, o un `dict` donde las claves son los nombres de los sub_configs, en cuyo caso cada submodelo distribuirá el valor correspondiente.

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

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

**Parámetros:**

use_kernels (`bool`) : Indica si se debe usar la biblioteca `kernels` para aplicar kernelización a algunas capas del modelo.

kernel_config (`KernelConfig`, *opcional*) : La configuración del kernel que se usará para kernelizar el modelo. Si es `None`, se utilizará el mapeo de kernels predeterminado.

mode (`Mode`, *opcional*) : El modo que debe aplicarse durante `kernelize`. Opcional, por defecto se establece en modo de entrenamiento o de inferencia según la bandera interna `training`.

Establece si se debe usar o no la biblioteca `kernels` para kernelizar algunas capas del modelo.

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

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

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

Vincula los pesos del modelo. Si `recompute_mapping=False` (valor predeterminado cuando se llama internamente), se basará en el atributo `model.all_tied_weights_keys`, que contiene el mapeo `{target: source}` para los parámetros vinculados. Si `recompute_mapping=True`, volverá a revisar todos los submodelos internos y su configuración para determinar qué parámetros deben vincularse. Este es el valor predeterminado cuando se llama a `model.tie_weights()` de forma independiente, fuera de `__init__` y `from_pretrained`, por si los valores de la configuración se han modificado en algún lugar.

Ten en cuenta que durante `from_pretrained`, el atado es *simétrico*: si el mapeo indica "tie target -> source" pero `source` no está presente en el checkpoint mientras que `target` sí existe, *intercambiamos* source y target para poder atar todo al parámetro que realmente existe.

#### a[[transformers.PreTrainedModel.to]]

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

Un valor simulado para una ruta con puntos (p. ej., `torch.float32`): las cadenas de acceso a atributos y las llamadas se comportan como decoradores de paso, `repr` es la ruta con puntos, y su uso como clase base sustituye una base de `type` simple (PEP 560 `__mro_entries__`), de modo que las subclases reales conservan un metaclass normal y `inspect.signature` lee su `__init__` real en lugar del de un simulacro.

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

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

Muestra una advertencia única si los input_ids parecen contener relleno y no se proporcionó una máscara de atención.

Los modelos personalizados también deben incluir `_supports_assign_param_buffer`, que determina si superfast init puede aplicarse al modelo en particular. Una señal de que su modelo necesita esto es si `test_save_and_load_from_pretrained` falla. En ese caso, establézcalo en `False`.

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

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

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

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

Algunas utilidades para `torch.nn.Modules`, para usarse como mixin.

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

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

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

**Parámetros:**

only_trainable (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver únicamente el número de parámetros entrenables

exclude_embeddings (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver únicamente el número de parámetros que no son de incrustación

**Devuelve:** `int`

El número de parámetros.

Obtener el número de parámetros (opcionalmente, entrenables o no de incrustaciones) en el módulo.

## Subir al Hub[[transformers.utils.PushToHubMixin]]

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

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

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

Un Mixin que contiene la funcionalidad para subir un modelo o tokenizador al 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)
```

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

**Parámetros:**

repo_id (`str`) : El nombre del repositorio al que deseas enviar tu {object}. Debe incluir el nombre de tu organización cuando se envía a una organización determinada.

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

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 {object_files} al 🤗 Model Hub.

Ejemplos:

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