# Modelos

Esta página contiene la documentación de referencia de la API para crear y descubrir modelos de `timm`, sus configuraciones preentrenadas y los helpers de checkpoint / Hub, así como una descripción general de la interfaz compartida por los modelos de `timm`. Las arquitecturas individuales se tratan en los [resúmenes de modelos](../models) y en las páginas de cada modelo.

## Uso

Los modelos se crean por nombre con [`create_model`](#timm.create_model). El nombre selecciona una arquitectura registrada en `timm`, opcionalmente con una etiqueta de preentrenamiento después de un `.` (`resnet50.a1_in1k`), o un modelo en el Hugging Face Hub o en una carpeta local mediante un prefijo de origen. Los argumentos de palabra clave que `create_model` no utiliza directamente se pasan a la función de entrada del modelo y, desde allí, al constructor de la clase del modelo, por lo que se puede establecer cualquier argumento específico del modelo.

```python
import torch
import timm

# Random init (pretrained=False is the default). The tag selects the pretrained cfg, and the weights loaded with
# pretrained=True. Without a tag the architecture's default tag is used.
model = timm.create_model('vit_tiny_patch16_224.augreg_in21k_ft_in1k')
print(model.pretrained_cfg['mean'], model.pretrained_cfg['crop_pct'])  # (0.5, 0.5, 0.5) 0.9

# Model arguments pass through to the model class, a 10 class head, single channel input and regularization.
model = timm.create_model('resnet50', num_classes=10, in_chans=1, drop_rate=0.2, drop_path_rate=0.05)

# Discover models, filters are fnmatch wildcards.
timm.list_models('convnext*')  # architecture names
timm.list_pretrained('resnet50.*')  # architecture.tag names w/ pretrained weights
timm.list_models(module='vision_transformer', pretrained=True)

# Image preprocessing to match the model's pretrained cfg (input size, interpolation, crop, mean / std).
model = timm.create_model('vit_tiny_patch16_224.augreg_in21k_ft_in1k')
data_config = timm.data.resolve_model_data_config(model)
transform = timm.data.create_transform(**data_config, is_training=False)

x = torch.randn(2, 3, 224, 224)
features = model.forward_features(x)  # unpooled features, (2, 197, 192)
pre_logits = model.forward_head(features, pre_logits=True)  # pooled features, (2, 192)
logits = model.forward_head(features)  # same as model(x), (2, 1000)

model.reset_classifier(5)  # replace the classifier w/ a new 5 class one
model.set_input_size(img_size=(384, 384))  # resample the position embedding for a new resolution
logits = model(torch.randn(2, 3, 384, 384))  # (2, 5)
```

El script de entrenamiento (`train.py`) expone los argumentos comunes a través de estas banderas:

- **`--model`** selecciona el modelo.
- **`--pretrained`** carga los pesos preentrenados.
- **`--num-classes`** establece el tamaño del clasificador (`num_classes`).
- **`--in-chans`** establece los canales de entrada (`in_chans`).
- **`--gp`** establece el tipo de agrupación global (`global_pool`).
- **`--drop`** establece el dropout del clasificador (`drop_rate`).
- **`--drop-path`** establece la profundidad estocástica (`drop_path_rate`).
- **`--pretrained-path`** carga pesos preentrenados desde un archivo local con adaptación del clasificador / convolución de entrada (`pretrained_cfg_overlay=dict(file=...)`).
- **`--initial-checkpoint`** carga un checkpoint después de crear el modelo, sin adaptación (`checkpoint_path`).
- **`--model-kwargs key=value ...`** pasa cualquier otro argumento del modelo.

Consulte el [quickstart](../quickstart) para una introducción.

### Nombres de modelos

| Nombre | Fuente |
|---|---|
| `resnet50` | Arquitectura en el registro de `timm`, con su configuración preentrenada predeterminada (aquí `a1_in1k`) |
| `resnet50.a1_in1k` | Etiqueta de arquitectura + preentrenada, una etiqueta desconocida genera un error |
| `hf-hub:timm/resnet50.a1_in1k` | El repositorio de Hugging Face Hub, la arquitectura, la configuración preentrenada y los argumentos del modelo provienen de su `config.json`, `@revision` selecciona una revisión |
| `local-dir:/path/to/folder` | Carpeta local con un `config.json` y pesos, tal como los escribe [`save_for_hf`](#timm.models.save_for_hf) |

El Hub y las fuentes locales leen la configuración incluso con `pretrained=False`; los pesos solo se cargan con `pretrained=True`. Un nombre sin prefijo de fuente que contenga `/`, `\` o `:` genera un `ValueError` en lugar de recurrir a un modelo del registro con el mismo nombre. `hf_hub:` es un alias obsoleto de `hf-hub:`.

### Argumentos comunes

- **`pretrained`** carga los pesos de la configuración preentrenada, desde `state_dict` o `file` si están definidos, en caso contrario desde el Hub (`hf_hub_id`) cuando `huggingface_hub` está instalado, o desde la `url`. La adaptación del clasificador / convolución de entrada a continuación permite crear un modelo preentrenado para el ajuste fino en una sola llamada.
- **`num_classes`** define el tamaño del clasificador, `0` elimina el clasificador. El valor predeterminado proviene de la configuración preentrenada. Al cargar pesos preentrenados, un número de clases diferente descarta los pesos del clasificador (se dejan en la inicialización aleatoria).
- **`global_pool`** establece el tipo de agrupación; las opciones son específicas del modelo (p. ej. `avg`, `max`, `avgmax`, `catavgmax` para la mayoría de las convnets, `token`, `avg`, `map` para ViT), y `''` desactiva la agrupación.
- **`in_chans`** establece los canales de entrada. El valor predeterminado proviene de la cfg preentrenada. Al cargar pesos preentrenados, los pesos de la primera conv se adaptan, si se admite, cuando este valor difiere del número de canales del checkpoint de origen (`input_size[0]` en la cfg preentrenada).
- **`drop_rate`** establece el dropout del clasificador, compatible con la mayoría de los modelos.
- **`drop_path_rate`** establece la profundidad estocástica, admitida por la mayoría de los modelos.
- **`img_size`** es un argumento de modelos de estilo ViT y otros con un tamaño de entrada fijo; están construidos para la configuración preentrenada `input_size` a menos que se establezca.
- **`dynamic_img_size=True`** en las familias ViT y EVA re-muestrea el embedding de posición al tamaño de entrada en cada pasada hacia adelante.
- **`features_only`** (con `out_indices`, `output_stride`, `feature_cls`) envuelve el modelo como un backbone de características que devuelve mapas de características, consulte [extracción de características](../feature_extraction).
- **`pretrained_cfg`** reemplaza la configuración preentrenada (una etiqueta, un diccionario o [`PretrainedCfg`](#timm.models.PretrainedCfg)).
- **`pretrained_cfg_overlay`** sobrescribe algunos de sus campos, por ejemplo, `pretrained_cfg_overlay=dict(file='weights.pth')` carga pesos de `pretrained=True` desde un archivo local, con la adaptación del clasificador / conv de entrada anterior (como lo hace `--pretrained-path` en `train.py`).
- **`checkpoint_path`** carga un checkpoint con [`load_checkpoint`](#timm.models.load_checkpoint) después de que se crea el modelo. Es una carga estricta sin adaptación; se usan los pesos EMA si el checkpoint los tiene.
- **`cache_dir`** reemplaza la caché de descarga para los pesos preentrenados y las configuraciones del Hub.
- **`device`** se pasa a la clase del modelo, los parámetros se crean directamente en el dispositivo. `device='meta'` crea un modelo sin asignar memoria para sus pesos.
- **`dtype`** se pasa a la clase del modelo y los parámetros se crean directamente en ese dtype.
- **`scriptable`** establece las banderas de configuración de capas para el scripting de TorchScript.
- **`exportable`** establece las banderas de configuración de capas para la exportación / el trazado.
- **`no_jit`** establece las banderas de configuración de capa para deshabilitar las capas con guiones de jit.

Los argumentos configurados en `None` se descartan antes de llegar al modelo, por lo que se aplican los valores predeterminados del modelo. Los argumentos que la clase del modelo no acepta provocan un `TypeError` en la mayoría de los modelos; algunos ignoran los argumentos desconocidos.

### Configuración preentrenada

Las arquitecturas tienen uno o más cfgs preentrenados, uno por etiqueta, registrados con el modelo. Un cfg describe los pesos (ubicación, licencia, origen) y cómo se entrenó el modelo y cómo debe evaluarse con ellos. Los modelos creados por `create_model` tienen su cfg como un dict en `model.pretrained_cfg` (`model.default_cfg` es un alias), y las versiones del registro se devuelven como instancias de [`PretrainedCfg`](#timm.models.PretrainedCfg) por [`get_pretrained_cfg`](#timm.get_pretrained_cfg).

| Campo | Descripción |
|---|---|
| `architecture`, `tag` | Arquitectura del modelo y etiqueta preentrenada |
| `hf_hub_id`, `url`, `file`, `state_dict` | Fuentes de pesos (ver `pretrained` arriba) |
| `input_size`, `test_input_size`, `fixed_input_size` | Tamaño de entrada para el entrenamiento (y evaluación predeterminada), tamaño de evaluación utilizado con `use_test_size=True` (si es diferente), si el modelo tiene un tamaño de entrada fijo (argumento `img_size`) |
| `interpolation`, `crop_pct`, `test_crop_pct`, `crop_mode` | Evaluación de la interpolación de redimensionado, la fracción de recorte (con el modo de recorte `center` predeterminado, la imagen se redimensiona a `input_size / crop_pct` y luego se recorta desde el centro) y el modo de recorte |
| `mean`, `std` | Normalización de entrada |
| `num_classes`, `label_names`, `label_descriptions` | Tamaño del clasificador y etiquetas (cuando se conocen) |
| `classifier`, `first_conv` | Nombres de los módulos del clasificador y de la primera conv, utilizados para adaptar los pesos al cargar |
| `license`, `origin_url`, `paper_ids`, `paper_name`, `notes` | Metadatos de los pesos |

Los campos de entrada son lo que [`resolve_data_config`](data#timm.data.resolve_data_config) / [`resolve_model_data_config`](data#timm.data.resolve_model_data_config) resuelven en una configuración de datos para las transformaciones y el cargador del conjunto de datos. La cfg describe el punto de control de origen y no se actualiza cuando el modelo se crea o se modifica de manera diferente (`num_classes`, `in_chans`, `img_size`, `set_input_size()`). Los canales de entrada actuales, el tamaño y la restricción de tamaño fijo del modelo se rastrean por separado: [`get_model_input_config`](#timm.models.get_model_input_config) los devuelve, y [`resolve_input_data_config`](data#timm.data.resolve_input_data_config) resuelve una configuración de datos en relación con ellos (como lo hacen los scripts de entrenamiento, validación e inferencia). [`get_model_args`](#timm.models.get_model_args) devuelve los argumentos para reconstruir el modelo tal como está ahora, que [`save_for_hf`](#timm.models.save_for_hf) escribe en la configuración exportada. Consulte [adaptar y exportar modelos](../model_adaptation) para más detalles.

### Interfaz del modelo

Los modelos de `timm` comparten una interfaz común más allá de `forward()`: la separación en `forward_features()` / `forward_head()`, el restablecimiento del clasificador, las características intermedias, el redimensionamiento de la entrada y los hooks de entrenamiento, como el checkpointing de gradientes y el agrupamiento de parámetros. Esto se describe en [la API de modelos de timm](../model_api), incluyendo qué familias de modelos admiten qué partes.

### Puntos de control y el Hub

- [`load_checkpoint`](#timm.models.load_checkpoint) carga un archivo de checkpoint (PyTorch o `.safetensors`) en un modelo.
- [`load_state_dict`](#timm.models.load_state_dict) lee un archivo de punto de control y devuelve su diccionario de estado.
- [`resume_checkpoint`](#timm.models.resume_checkpoint) restaura el estado del modelo, el optimizador y el escalador de pérdida de un punto de control de `train.py` y devuelve la época desde la que reanudar.

`load_checkpoint` y `load_state_dict` seleccionan por defecto los pesos EMA de un checkpoint de `train.py` (`use_ema`) y eliminan los prefijos de clave `module.` (DDP) y `_orig_mod.` (`torch.compile`).

- [`save_for_hf`](#timm.models.save_for_hf) escribe los pesos y un `config.json` (arquitectura, cfg preentrenado, `model_args`, `label_names`) en una carpeta.
- [`push_to_hf_hub`](#timm.models.push_to_hf_hub) sube los pesos y la configuración a un repositorio del Hub con una tarjeta de modelo generada si el repositorio no tiene ninguna.

A continuación, el modelo se crea con `hf-hub:` o `local-dir:`, consulte [compartir y cargar modelos](../hf_hub).

```python
import timm
from timm.models import save_for_hf

model = timm.create_model('resnet18', num_classes=4)
# ... fine-tune
save_for_hf(model, 'my_resnet18', model_config=dict(label_names=['a', 'b', 'c', 'd']), safe_serialization=True)
model = timm.create_model('local-dir:my_resnet18', pretrained=True)  # 4 classes, weights and labels restored
print(model.pretrained_cfg['label_names'])
```

### Modelos personalizados

Una función de punto de entrada de modelo decorada con [`register_model`](#timm.models.register_model) se añade al registro, por lo que puede crearse con `create_model` y encontrarse con `list_models`. Los puntos de entrada en `timm` construyen su modelo con [`build_model_with_cfg`](#timm.models.build_model_with_cfg), que gestiona la configuración preentrenada, la carga de pesos preentrenados y `features_only`.

## API

### Creación de modelos[[timm.create_model]]

#### timm.create_model[[timm.create_model]]

```python
timm.create_model(model_name: str, pretrained: bool = False, pretrained_cfg: typing.Union[str, typing.Dict[str, typing.Any], timm.models._pretrained.PretrainedCfg, NoneType] = None, pretrained_cfg_overlay: typing.Optional[typing.Dict[str, typing.Any]] = None, checkpoint_path: typing.Union[str, pathlib.Path, NoneType] = None, cache_dir: typing.Union[str, pathlib.Path, NoneType] = None, scriptable: typing.Optional[bool] = None, exportable: typing.Optional[bool] = None, no_jit: typing.Optional[bool] = None, **kwargs: typing.Any)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_factory.py#L162)

**Parámetros:**

model_name : Nombre del modelo que se va a instanciar.

pretrained : Si se establece en *True*, carga los pesos preentrenados de ImageNet-1k.

pretrained_cfg : Pasa un pretrained_cfg externo para el modelo.

pretrained_cfg_overlay : Reemplaza los pares clave-valor en base pretrained_cfg con estos.

checkpoint_path : Ruta del punto de control para cargar _después_ de que el modelo se inicialice.

cache_dir : Anula el directorio de caché del modelo para Hugging Face Hub y los puntos de control de Torch.

scriptable : Establece la configuración de capas para que el modelo sea scriptable con jit (aún no funciona para todos los modelos).

exportable : Establece la configuración de capas para que el modelo sea trazable / exportable a ONNX (aún no está completamente implementado/respetado).

no_jit : Configura la configuración de capas para que el modelo no utilice capas con guiones de jit (hasta ahora, solo activaciones).

Crea un modelo.

Busque la función de punto de entrada del modelo y pase los argumentos relevantes para crear un nuevo modelo.

Consejo: **kwargs se pasará a la función de entrada y luego a `timm.models.build_model_with_cfg()` y a la función __init__() de la clase del modelo. Los valores de kwargs establecidos en None se eliminan antes de pasarlos.

Argumentos de palabra clave: drop_rate (float): Tasa de dropout del clasificador para el entrenamiento. drop_path_rate (float): Tasa de profundidad estocástica para el entrenamiento. global_pool (str): Tipo de agrupación global del clasificador.

Ejemplos:

```python
>>> from timm import create_model

>>> # Create a MobileNetV3-Large model with no pretrained weights.
>>> model = create_model('mobilenetv3_large_100')

>>> # Create a MobileNetV3-Large model with pretrained weights.
>>> model = create_model('mobilenetv3_large_100', pretrained=True)
>>> model.num_classes
1000

>>> # Create a MobileNetV3-Large model with pretrained weights and a new head with 10 classes.
>>> model = create_model('mobilenetv3_large_100', pretrained=True, num_classes=10)
>>> model.num_classes
10

>>> # Create a Dinov2 small model with pretrained weights and save weights in a custom directory.
>>> model = create_model('vit_small_patch14_dinov2.lvd142m', pretrained=True, cache_dir="/data/my-models")
>>> # Data will be stored at */data/my-models/models--timm--vit_small_patch14_dinov2.lvd142m/*
```

### Descubrimiento de modelos[[timm.list_models]]

#### timm.list_models[[timm.list_models]]

```python
timm.list_models(filter: typing.Union[str, typing.Iterable[str]] = '', module: typing.Union[str, typing.Iterable[str]] = '', pretrained: bool = False, exclude_filters: typing.Union[str, typing.Iterable[str]] = '', name_matches_cfg: bool = False, include_tags: typing.Optional[bool] = None)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_registry.py#L254)

**Parámetros:**

filter : Filtro(s) comodín que funcionan con fnmatch.

module : Limita la selección de modelos a submódulo(s) específico(s) (p. ej., 'vision_transformer').

pretrained : Incluye solo modelos con pesos preentrenados válidos si es True.

exclude_filters : Filtro(s) comodín para excluir modelos después de incluirlos con filter.

name_matches_cfg : Incluye solo los modelos cuyo model_name coincide con el nombre de default_cfg (excluye algunos alias).

include_tags : Incluye etiquetas preentrenadas en los nombres de los modelos (model.tag). Si es None, se establece en el valor de pretrained.

**Devuelve:**

La lista ordenada de nombres de modelos.

Devuelve una lista de los nombres de modelos disponibles, ordenados de forma natural.

Ejemplo: list_models('gluon_resnet*') -- devuelve todos los modelos que comienzan por 'gluon_resnet' list_models('*resnext*', 'resnet') -- devuelve todos los modelos con 'resnext' en el módulo 'resnet'

#### timm.list_pretrained[[timm.list_pretrained]]

```python
timm.list_pretrained(filter: typing.Union[str, typing.Iterable[str]] = '', exclude_filters: typing.Union[str, typing.Iterable[str]] = '')
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_registry.py#L329)

**Parámetros:**

filter : Filtro(s) comodín que funcionan con fnmatch.

exclude_filters : Filtro(s) comodín para excluir modelos después de incluirlos con filter.

**Devuelve:**

La lista ordenada de nombres de modelos.

Devuelve una lista de nombres de modelos preentrenados (con etiquetas), ordenados de forma natural.

#### timm.list_modules[[timm.list_modules]]

```python
timm.list_modules()
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_registry.py#L385)

Devuelve una lista ordenada de nombres de módulos que contienen puntos de entrada de modelos.

#### timm.is_model[[timm.is_model]]

```python
timm.is_model(model_name: str)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_registry.py#L363)

Comprueba si una arquitectura de modelo está registrada, ignorando cualquier etiqueta preentrenada.

#### timm.is_model_pretrained[[timm.is_model_pretrained]]

```python
timm.is_model_pretrained(model_name: str)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_registry.py#L404)

Comprueba si un nombre de modelo (con o sin etiqueta) tiene pesos preentrenados registrados.

#### timm.model_entrypoint[[timm.model_entrypoint]]

```python
timm.model_entrypoint(model_name: str, module_filter: typing.Optional[str] = None)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_registry.py#L369)

**Parámetros:**

model_name : Nombre del modelo, con o sin una etiqueta de preentrenamiento.

module_filter : Si se establece, se genera una excepción si el modelo no está en este submódulo.

**Devuelve:**

La función de entrada del modelo.

Obtiene la función de punto de entrada del modelo para un nombre de modelo, ignorando cualquier etiqueta preentrenada.

### Configuración preentrenada[[timm.get_pretrained_cfg]]

#### timm.get_pretrained_cfg[[timm.get_pretrained_cfg]]

```python
timm.get_pretrained_cfg(model_name: str, allow_unregistered: bool = True)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_registry.py#L409)

**Parámetros:**

model_name : Nombre del modelo, con o sin una etiqueta de preentrenamiento.

allow_unregistered : Devuelve None en lugar de lanzar una excepción si la arquitectura no tiene cfgs preentrenados.

**Devuelve:**

La configuración preentrenada cfg, o None si no está registrada y se permite.

**Excepciones:** ``RuntimeError``

- ``RuntimeError`` -- Si la etiqueta no es válida para la arquitectura, o si no tiene cfgs y allow_unregistered es False.

Obtenga una copia de la cfg preentrenada para un nombre de modelo; se utiliza la etiqueta predeterminada si no se especifica ninguna.

#### timm.get_pretrained_cfg_value[[timm.get_pretrained_cfg_value]]

```python
timm.get_pretrained_cfg_value(model_name: str, cfg_key: str)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_registry.py#L434)

**Excepciones:** ``RuntimeError``

- ``RuntimeError`` -- Si el modelo no tiene un cfg preentrenado registrado o la etiqueta no es válida.

Obtén un valor de cfg preentrenado específico por clave para un nombre de modelo, o None si la clave no existe.

#### timm.models.get_arch_pretrained_cfgs[[timm.models.get_arch_pretrained_cfgs]]

```python
timm.models.get_arch_pretrained_cfgs(model_name: str)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_registry.py#L444)

**Parámetros:**

model_name : Nombre del modelo, cualquier etiqueta preentrenada se ignora.

**Devuelve:**

Diccionario de configuraciones preentrenadas indexadas por el nombre del modelo con etiqueta, vacío si la arquitectura es desconocida.

Obtenga copias de todas las configuraciones preentrenadas para una arquitectura de modelo.

#### timm.models.PretrainedCfg[[timm.models.PretrainedCfg]]

```python
timm.models.PretrainedCfg(url: typing.Union[str, typing.Tuple[str, str], NoneType] = None, file: typing.Optional[str] = None, state_dict: typing.Optional[typing.Dict[str, typing.Any]] = None, hf_hub_id: typing.Optional[str] = None, hf_hub_filename: typing.Optional[str] = None, source: typing.Optional[str] = None, architecture: typing.Optional[str] = None, tag: typing.Optional[str] = None, custom_load: bool = False, input_size: typing.Tuple[int, int, int] = (3, 224, 224), test_input_size: typing.Optional[typing.Tuple[int, int, int]] = None, min_input_size: typing.Optional[typing.Tuple[int, int, int]] = None, fixed_input_size: bool = False, interpolation: str = 'bicubic', crop_pct: float = 0.875, test_crop_pct: typing.Optional[float] = None, crop_mode: str = 'center', mean: typing.Tuple[float, ...] = (0.485, 0.456, 0.406), std: typing.Tuple[float, ...] = (0.229, 0.224, 0.225), num_classes: int = 1000, label_offset: typing.Optional[int] = None, label_names: typing.Optional[typing.Tuple[str]] = None, label_descriptions: typing.Optional[typing.Dict[str, str]] = None, pool_size: typing.Optional[typing.Tuple[int, ...]] = None, test_pool_size: typing.Optional[typing.Tuple[int, ...]] = None, first_conv: typing.Optional[str] = None, classifier: typing.Optional[str] = None, license: typing.Optional[str] = None, description: typing.Optional[str] = None, origin_url: typing.Optional[str] = None, paper_name: typing.Optional[str] = None, paper_ids: typing.Union[str, typing.Tuple[str], NoneType] = None, notes: typing.Optional[typing.Tuple[str]] = None)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_pretrained.py#L11)

### Entrada y exportación del modelo actual[[timm.models.get_model_input_config]]

#### timm.models.get_model_input_config[[timm.models.get_model_input_config]]

```python
timm.models.get_model_input_config(model: Module)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_input.py#L113)

Devuelve los canales de imagen actuales, el tamaño nominal y la restricción de tamaño fijo.

El tamaño nominal es una recomendación para los modelos flexibles. Los metadatos del punto de control de origen permanecen en `model.pretrained_cfg` y nunca se modifican aquí.

#### timm.models.get_model_traits[[timm.models.get_model_traits]]

```python
timm.models.get_model_traits(model: Module)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_input.py#L101)

Devuelve una copia de las características del modelo, aumentada con las cantidades actuales de canales y clases.

Los atributos existentes `in_chans` y `num_classes` siguen siendo los autoritativos; se leen aquí en lugar de duplicarse en los rasgos almacenados. Los atributos ausentes en un envoltorio de características se omiten.

#### timm.models.get_model_args[[timm.models.get_model_args]]

```python
timm.models.get_model_args(model: Module, overrides: typing.Optional[typing.Dict[str, typing.Any]] = None)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_input.py#L170)

Devuelve los argumentos de reconstrucción, incluidos los cambios compatibles realizados después de la construcción.

Los argumentos de tiempo de ejecución se excluyen mediante la fábrica. Las tasas de omisión se omiten a menos que se especifiquen explícitamente en las sobrescripciones. Los argumentos de arquitectura no serializables requieren un reemplazo serializable explícito al exportar.

#### timm.models.resolve_model_input_args[[timm.models.resolve_model_input_args]]

```python
timm.models.resolve_model_input_args(model_name: str, args: typing.Optional[typing.Dict[str, typing.Any]] = None, **model_kwargs)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_factory.py#L123)

Resuelve las solicitudes de entrada del script en argumentos para `create_model`.

Los argumentos del modelo guardado son valores predeterminados. Las solicitudes explícitas de canal/tamaño seleccionan el objetivo sin sobrescribir los metadatos que describen el punto de control de origen.

#### timm.models.adapt_input_conv[[timm.models.adapt_input_conv]]

```python
timm.models.adapt_input_conv(in_chans: int, conv_weight: Tensor, base_chans: int = 3)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_manipulate.py#L293)

**Parámetros:**

in_chans : Número de canales de entrada para el modelo objetivo.

conv_weight : Pesos preentrenados de Conv2d en el diseño OIHW.

base_chans : Número de canales de entrada física utilizados para el preentrenamiento. Esto puede diferir de la dimensión de entrada del peso para los tallos space-to-depth.

**Devuelve:**

Pesos con canales repetidos o truncados escalados por `base_chans / in_chans`. Las entradas de un solo canal suman los canales de origen, preservando los grupos espaciales separados para los tallos space-to-depth. Las cantidades de canales coincidentes no se modifican.

**Excepciones:** `ValueError` o `NotImplementedError`

- `ValueError` -- Si el número de canales no es positivo.
- `NotImplementedError` -- Si el formato de los pesos no se puede adaptar.

Adapta los pesos de la convolución de entrada preentrenada a un número de canales diferente.

### Puntos de control y Hub[[timm.models.load_checkpoint]]

#### timm.models.load_checkpoint[[timm.models.load_checkpoint]]

```python
timm.models.load_checkpoint(model: Module, checkpoint_path: str, use_ema: bool = True, device: typing.Union[str, torch.device] = 'cpu', strict: bool = True, remap: bool = False, filter_fn: typing.Optional[typing.Callable] = None, weights_only: bool = True)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_helpers.py#L186)

**Parámetros:**

model : Modelo en el que cargar el punto de control.

checkpoint_path : Ruta al archivo de punto de control.

use_ema : Si se deben usar los pesos EMA si están disponibles.

device : Dispositivo en el que cargar el punto de control.

strict : Si se debe aplicar estrictamente que las claves de state_dict coincidan.

remap : Si se deben remapear las claves del state dict por orden.

filter_fn : Función opcional para filtrar el state dict.

weights_only : Si se deben cargar solo los pesos (parámetro de torch.load).

**Devuelve:**

Claves incompatibles de model.load_state_dict().

Cargar el punto de control en el modelo.

Native PyTorch checkpoints are loaded as state dictionaries. NumPy `.npz`/``.npy` checkpoints are foreign, model-specific formats and are delegated to the model's `load_pretrained`` helper.

#### timm.models.load_state_dict[[timm.models.load_state_dict]]

```python
timm.models.load_state_dict(checkpoint_path: str, use_ema: bool = True, device: typing.Union[str, torch.device] = 'cpu', weights_only: bool = True)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_helpers.py#L143)

**Parámetros:**

checkpoint_path : Ruta al archivo de punto de control.

use_ema : Si se deben usar los pesos EMA si están disponibles.

device : Dispositivo en el que cargar el punto de control.

weights_only : Si se deben cargar solo los pesos (parámetro de torch.load).

**Devuelve:**

State dictionary cargado desde el checkpoint.

Cargar el diccionario de estado desde el archivo de punto de control.

#### timm.models.resume_checkpoint[[timm.models.resume_checkpoint]]

```python
timm.models.resume_checkpoint(model: Module, checkpoint_path: str, optimizer: typing.Optional[torch.optim.Optimizer] = None, loss_scaler: typing.Optional[typing.Any] = None, log_info: bool = True, weights_only: bool = True)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_helpers.py#L261)

**Parámetros:**

model : Modelo en el que cargar el punto de control.

checkpoint_path : Ruta al archivo de punto de control.

optimizer : Optimizador opcional para restaurar el estado.

loss_scaler : Escalador de pérdida AMP opcional para restaurar el estado.

log_info : Si se registran las informaciones de carga.

weights_only : Si se deben cargar solo los pesos mediante torch.load.

**Devuelve:**

Número de época si está disponible, en caso contrario None.

Reanudar el entrenamiento desde un punto de control.

#### timm.models.save_for_hf[[timm.models.save_for_hf]]

```python
timm.models.save_for_hf(model: Module, save_directory: str, model_config: typing.Optional[dict] = None, model_args: typing.Optional[dict] = None, safe_serialization: typing.Union[bool, typing.Literal['both']] = False, data_config: typing.Optional[dict] = None)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_hub.py#L449)

Guarde los pesos nativos y su configuración actual de modelo y preprocesamiento.

#### timm.models.push_to_hf_hub[[timm.models.push_to_hf_hub]]

```python
timm.models.push_to_hf_hub(model: Module, repo_id: str, commit_message: str = 'Add model', token: typing.Optional[str] = None, revision: typing.Optional[str] = None, private: bool = False, create_pr: bool = False, model_config: typing.Optional[dict] = None, model_card: typing.Optional[dict] = None, model_args: typing.Optional[dict] = None, task_name: str = 'image-classification', safe_serialization: typing.Union[bool, typing.Literal['both']] = 'both', data_config: typing.Optional[dict] = None)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_hub.py#L480)

**Parámetros:**

(...) --

model_args : Argumentos de reconstrucción explícitos que complementan a los registrados por la fábrica.

data_config : Preprocesamiento utilizado con el punto de control exportado, incluido el tamaño de entrada y la normalización.

safe_serialization (`bool` o `"both"`, *opcional*, valor predeterminado `False`) : Si se guarda el modelo usando `safetensors` o de la forma tradicional de PyTorch (que usa `pickle`). Se puede establecer en `"both"` para subir tanto los pesos seguros como los inseguros.

### Modelos personalizados[[timm.models.register_model]]

#### timm.models.register_model[[timm.models.register_model]]

```python
timm.models.register_model(fn: typing.Callable[..., typing.Any])
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_registry.py#L114)

**Parámetros:**

fn : Función de punto de entrada del modelo, registrada bajo su __name__.

**Devuelve:**

La función de punto de entrada sin modificar.

Decorador que registra una función de punto de entrada de un modelo y cualquier configuración preentrenada en los default_cfgs de su módulo.

Registrar un nombre que ya existe sobrescribe el registro anterior y sus cfgs preentrenados.

#### timm.models.build_model_with_cfg[[timm.models.build_model_with_cfg]]

```python
timm.models.build_model_with_cfg(model_cls: typing.Union[typing.Type[~ModelT], typing.Callable[..., ~ModelT]], variant: str, pretrained: bool, pretrained_cfg: typing.Optional[typing.Dict] = None, pretrained_cfg_overlay: typing.Optional[typing.Dict] = None, model_cfg: typing.Optional[typing.Any] = None, feature_cfg: typing.Optional[typing.Dict] = None, pretrained_strict: bool = True, pretrained_filter_fn: typing.Optional[typing.Callable] = None, cache_dir: typing.Union[str, pathlib.Path, NoneType] = None, kwargs_filter: typing.Optional[typing.Tuple[str]] = None, pretrained_model_args: typing.Optional[typing.Dict] = None, **kwargs)
```

[Fuente](https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/_builder.py#L427)

**Parámetros:**

model_cls : Clase de modelo

variant : Nombre de la variante del modelo

pretrained : Cargar los pesos preentrenados

pretrained_cfg : Configuración de pesos preentrenados/tarea del modelo

pretrained_cfg_overlay : Entradas que reemplazarán a las de pretrained_cfg

model_cfg : Configuración de la arquitectura del modelo

feature_cfg : Configuración del adaptador de extracción de características

pretrained_strict : Cargar pesos preentrenados de forma estricta

pretrained_filter_fn : Función filtrable para pesos preentrenados

cache_dir : Anular el directorio de caché del modelo para Hugging Face Hub y puntos de control de Torch

kwargs_filter : Claves de Kwargs para filtrar (eliminar) antes de pasarlas al modelo

pretrained_model_args : Argumentos de reconstrucción que describen el punto de control de origen.

- ****kwargs** : Argumentos del modelo que se pasan al __init__ del modelo

Construir un modelo con default_cfg especificado y model_cfg opcional

Esta función auxiliar facilita la construcción de un modelo, incluyendo:
* gestión de default_cfg y la carga de pesos preentrenados asociados
* pasando el parámetro opcional model_cfg para modelos con especificación de arquitectura basada en configuración
* adaptación de modelos features_only
* configuración de poda / adaptación del modelo