Introducción

Esta guía de inicio rápido está destinada a los desarrolladores que están listos para sumergirse en el código y ver un ejemplo de cómo integrar timm en su flujo de trabajo de entrenamiento de modelos.

Primero, deberá instalar timm. Para obtener más información sobre la instalación, consulte Installation.

pip install timm

Cargar un modelo preentrenado

Los modelos preentrenados se pueden cargar usando create_model().

Aquí cargamos el modelo preentrenado mobilenetv3_large_100.

>>> import timm

>>> m = timm.create_model('mobilenetv3_large_100', pretrained=True)
>>> m.eval()

Note: The returned PyTorch model is set to train mode by default, so you must call .eval() on it if you plan to use it for inference.

Listar modelos con pesos preentrenados

Para listar los modelos empaquetados con timm, puedes usar list_models(). Si especificas pretrained=True, esta función solo devolverá los nombres de modelos que tengan pesos preentrenados asociados disponibles.

>>> import timm
>>> from pprint import pprint
>>> model_names = timm.list_models(pretrained=True)
>>> pprint(model_names)
[
    'adv_inception_v3',
    'cspdarknet53',
    'cspresnext50',
    'densenet121',
    'densenet161',
    'densenet169',
    'densenet201',
    'densenetblur121d',
    'dla34',
    'dla46_c',
]

También puede listar modelos con un patrón específico en su nombre.

>>> import timm
>>> from pprint import pprint
>>> model_names = timm.list_models('*resne*t*')
>>> pprint(model_names)
[
    'cspresnet50',
    'cspresnet50d',
    'cspresnet50w',
    'cspresnext50',
    ...
]

Ajustar un modelo preentrenado

Puede ajustar cualquier modelo preentrenado simplemente cambiando el clasificador (la última capa).

>>> model = timm.create_model('mobilenetv3_large_100', pretrained=True, num_classes=NUM_FINETUNE_CLASSES)

Para hacer un ajuste fino con tu propio conjunto de datos, debes escribir un bucle de entrenamiento de PyTorch o adaptar el script de entrenamiento de timm para usar tu conjunto de datos.

Para diferentes canales de entrada, establezca in_chans en la cantidad de canales objetivo del modelo; la configuración preentrenada debe describir los pesos de origen. Consulte Adapt and Export Models para la conversión de canales y el guardado de modelos adaptados con su configuración actual.

Usar un modelo preentrenado para la extracción de características

Sin modificar la red, se puede llamar a model.forward_features(input) en cualquier modelo en lugar del habitual model(input). Esto omitirá el clasificador de la cabeza y el agrupamiento global para las redes.

Para una guía más detallada sobre el uso de timm para la extracción de características, consulte Extracción de características.

>>> import timm
>>> import torch
>>> x = torch.randn(1, 3, 224, 224)
>>> model = timm.create_model('mobilenetv3_large_100', pretrained=True)
>>> features = model.forward_features(x)
>>> print(features.shape)
torch.Size([1, 960, 7, 7])

Aumento de imágenes

Para transformar imágenes en entradas válidas para un modelo, puede usar timm.data.create_transform(), proporcionando el input_size deseado que el modelo espera.

Esto devolverá una transformación genérica que utiliza valores predeterminados razonables.

>>> timm.data.create_transform((3, 224, 224))
Compose(
    Resize(size=256, interpolation=bilinear, max_size=None, antialias=True)
    CenterCrop(size=(224, 224))
    MaybeToTensor()
    Normalize(mean=tensor([0.4850, 0.4560, 0.4060]), std=tensor([0.2290, 0.2240, 0.2250]))
)

Los modelos preentrenados tienen transformaciones específicas que se aplicaron a las imágenes que se les proporcionó durante el entrenamiento. Si usas la transformación incorrecta en tu imagen, ¡el modelo no entenderá lo que está viendo!

Para averiguar qué transformaciones se utilizaron para un modelo preentrenado dado, podemos empezar por examinar su pretrained_cfg

>>> model.pretrained_cfg
{'url': 'https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/mobilenetv3_large_100_ra-f55367f5.pth',
 'hf_hub_id': 'timm/mobilenetv3_large_100.ra_in1k',
 'architecture': 'mobilenetv3_large_100',
 'tag': 'ra_in1k',
 'custom_load': False,
 'input_size': (3, 224, 224),
 'fixed_input_size': False,
 'interpolation': 'bicubic',
 'crop_pct': 0.875,
 'crop_mode': 'center',
 'mean': (0.485, 0.456, 0.406),
 'std': (0.229, 0.224, 0.225),
 'num_classes': 1000,
 'pool_size': (7, 7),
 'first_conv': 'conv_stem',
 'classifier': 'classifier',
 'license': 'apache-2.0'}

A continuación, podemos resolver solo la configuración relacionada con los datos usando timm.data.resolve_model_data_config().

>>> timm.data.resolve_model_data_config(model)
{'input_size': (3, 224, 224),
 'interpolation': 'bicubic',
 'mean': (0.485, 0.456, 0.406),
 'std': (0.229, 0.224, 0.225),
 'crop_pct': 0.875,
 'crop_mode': 'center'}

Podemos pasar esta configuración de datos a timm.data.create_transform() para inicializar la transformación asociada al modelo.

>>> data_cfg = timm.data.resolve_model_data_config(model)
>>> transform = timm.data.create_transform(**data_cfg)
>>> transform
Compose(
    Resize(size=256, interpolation=bicubic, max_size=None, antialias=True)
    CenterCrop(size=(224, 224))
    MaybeToTensor()
    Normalize(mean=tensor([0.4850, 0.4560, 0.4060]), std=tensor([0.2290, 0.2240, 0.2250]))
)

Note: Here, the pretrained model's config happens to be the same as the generic config we made earlier. This is not always the case. So, it's safer to use the data config to create the transform as we did here instead of using the generic transform.

Uso de modelos preentrenados para inferencia

Aquí, combinaremos las secciones anteriores y utilizaremos un modelo preentrenado para la inferencia.

Primero necesitaremos una imagen para realizar la inferencia. Aquí cargamos una imagen de una hoja desde la web:

>>> import requests
>>> from PIL import Image
>>> from io import BytesIO
>>> url = 'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/timm/cat.jpg'
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image

Esta es la imagen que cargamos:

Ahora, crearemos de nuevo nuestro modelo y transformaciones. Esta vez, nos aseguramos de poner el modelo en modo de evaluación.

>>> model = timm.create_model('mobilenetv3_large_100', pretrained=True).eval()
>>> transform = timm.data.create_transform(
    **timm.data.resolve_model_data_config(model)
)

Podemos preparar esta imagen para el modelo pasándola a la transformación.

>>> image_tensor = transform(image)
>>> image_tensor.shape
torch.Size([3, 224, 224])

Ahora podemos pasar esa imagen al modelo para obtener las predicciones. En este caso usamos unsqueeze(0), ya que el modelo espera una dimensión de lote.

>>> output = model(image_tensor.unsqueeze(0))
>>> output.shape
torch.Size([1, 1000])

Para obtener las probabilidades predichas, aplicamos softmax a la salida. Esto nos deja con un tensor de forma (num_classes,).

>>> probabilities = torch.nn.functional.softmax(output[0], dim=0)
>>> probabilities.shape
torch.Size([1000])

Ahora encontraremos los 5 índices y valores de clase más altos predichos usando torch.topk.

>>> values, indices = torch.topk(probabilities, 5)
>>> indices
tensor([281, 282, 285, 673, 670])

Si comprobamos las etiquetas de imagenet para el índice superior, podemos ver lo que el modelo predijo…

>>> IMAGENET_1k_URL = 'https://storage.googleapis.com/bit_models/ilsvrc2012_wordnet_lemmas.txt'
>>> IMAGENET_1k_LABELS = requests.get(IMAGENET_1k_URL).text.strip().split('\n')
>>> [{'label': IMAGENET_1k_LABELS[idx], 'value': val.item()} for val, idx in zip(values, indices)]
[{'label': 'tabby, tabby_cat', 'value': 0.5101025700569153},
 {'label': 'tiger_cat', 'value': 0.22490699589252472},
 {'label': 'Egyptian_cat', 'value': 0.1835290789604187},
 {'label': 'mouse, computer_mouse', 'value': 0.006752475164830685},
 {'label': 'motor_scooter, scooter', 'value': 0.004942195490002632}]

Update on GitHub