La Arquitectura ResNet (Residual Neural Network) es una familia de redes neuronales convolucionales profundas que utiliza conexiones residuales para facilitar el entrenamiento y la propagación de información a través de numerosas capas.

ResNet representa uno de los avances más influyentes en el desarrollo del Deep Learning aplicado a imágenes.

Su innovación principal consiste en permitir que determinados bloques aprendan transformaciones residuales, en lugar de obligarlos a reconstruir directamente toda la función deseada.

La expresión fundamental es:

y = F(x) + x

Donde:

• x representa la entrada de un bloque.
• F(x) representa una transformación neuronal aprendible.
• y representa la salida combinada.

Esta operación permite conservar una ruta directa para la información original mientras las capas convolucionales aprenden transformaciones adicionales.

La arquitectura fue presentada por Kaiming He, Xiangyu Zhang, Shaoqing Ren y Jian Sun en la investigación Deep Residual Learning for Image Recognition, publicada inicialmente en 2015 y presentada en CVPR 2016.

Sus experimentos demostraron que el aprendizaje residual podía facilitar la optimización de redes considerablemente más profundas que determinadas arquitecturas anteriores.

Entre las variantes más conocidas encontramos:

• ResNet-18.
• ResNet-34.
• ResNet-50.
• ResNet-101.
• ResNet-152.

Estas arquitecturas utilizan diferentes números de bloques y configuraciones internas.

Por ejemplo, ResNet-18 y ResNet-34 utilizan bloques residuales básicos de dos convoluciones principales.

En cambio, ResNet-50, ResNet-101 y ResNet-152 utilizan habitualmente bloques Bottleneck de tres convoluciones principales.

ResNet continúa siendo importante tanto por sus aplicaciones directas como por su influencia en otras arquitecturas.

Se utiliza para clasificación de imágenes, extracción de características visuales, detección de objetos, segmentación, Transfer Learning y Fine-Tuning.

También constituye una referencia fundamental para comprender los mecanismos de propagación de gradientes en redes profundas.

En el ámbito de la Visibilidad en Inteligencia Artificial (AI Visibility), ResNet puede utilizarse en sistemas que analizan imágenes de productos, logotipos, capturas de páginas web y otros activos visuales relacionados con marcas.

Sin embargo, ResNet no es por sí misma una herramienta para medir recomendaciones textuales de ChatGPT, Gemini o Claude.

Para ese objetivo normalmente se necesitan métodos específicos de procesamiento de lenguaje o modelos multimodales.

En este artículo explicamos cómo funciona ResNet, cuáles son sus principales variantes, cómo se construyen sus bloques, cómo utilizar modelos preentrenados y cómo desarrollar aplicaciones prácticas con Python, PyTorch, torchvision y Keras.

¿Qué es la Arquitectura ResNet?

ResNet es una arquitectura de red neuronal profunda basada en bloques que incorporan conexiones residuales, generalmente mediante sumas entre la entrada de un bloque y una transformación aprendible.

Definición breve: ResNet (Residual Neural Network) es una familia de redes neuronales profundas, principalmente convolucionales, que utiliza conexiones residuales para facilitar la optimización y el aprendizaje de representaciones en arquitecturas con numerosas capas.

ResNet no es un optimizador como AdamW o SGD.

Es una arquitectura neuronal.

Sus parámetros pueden entrenarse mediante distintos algoritmos de optimización.

¿Qué significa ResNet?

El término procede de:

Residual Network

En español:

Red Neuronal Residual.

Conceptos relacionados

• Residual Neural Network.
• Deep Residual Learning.
• Residual Block.
• BasicBlock.
• Bottleneck Block.
• Identity Shortcut.
• Projection Shortcut.
• Convolutional Neural Network.
• Feature Maps.
• Batch Normalization.
• Global Average Pooling.
• Transfer Learning.
• Fine-Tuning.

¿Por qué se desarrolló ResNet?

Antes de ResNet, aumentar la profundidad de una red neuronal podía producir dificultades importantes durante el entrenamiento.

Una arquitectura más profunda dispone potencialmente de mayor capacidad representacional.

Sin embargo, esa capacidad adicional no garantiza que el algoritmo de optimización encuentre una solución adecuada.

Los investigadores observaron un fenómeno denominado Degradation Problem.

¿Qué es el problema de degradación?

El problema aparece cuando aumentar la profundidad de una red produce una pérdida de entrenamiento superior o una precisión de entrenamiento inferior, incluso cuando la arquitectura más profunda debería tener suficiente capacidad para representar la solución de la red menos profunda.

Ejemplo conceptual

Consideremos:

Red A: 20 capas.

Red B: 40 capas.

La red B contiene capas adicionales.

En principio, determinadas configuraciones podrían permitir que esas capas actuasen aproximadamente como identidades.

Pero aprender esas identidades mediante una secuencia convencional de capas puede ser difícil.

¿Es lo mismo que Overfitting?

No.

Overfitting describe una diferencia entre el rendimiento de entrenamiento y la generalización.

El problema de degradación puede observarse incluso en la pérdida de entrenamiento.

Por tanto, está relacionado principalmente con dificultades de optimización.

¿Cómo resuelve ResNet parte de este problema?

En una red convencional, un bloque aprende una transformación:

H(x)

En una red residual, el bloque puede aprender:

F(x) = H(x) − x

Después calcula:

H(x) = F(x) + x

¿Por qué importa?

Si la transformación deseada se aproxima a la identidad, aprender F(x) cercana a cero puede resultar más sencillo que aprender directamente H(x).

Ejemplo

Una representación visual ya contiene información importante sobre bordes, formas y texturas.

Un bloque posterior puede modificar esa representación para incorporar características más complejas.

No necesita reconstruir necesariamente toda la información inicial.

Precaución

ResNet no obliga a que todas las transformaciones residuales sean pequeñas.

La magnitud de F(x) depende de los parámetros y de los datos.

Anatomía de una ResNet

Una ResNet clásica para clasificación de imágenes puede dividirse en varias etapas.

1. Stem o bloque inicial

La imagen entra en una convolución inicial.

En las variantes clásicas diseñadas para ImageNet suele utilizarse una convolución de 7 × 7 con stride 2, seguida de Batch Normalization, ReLU y Max Pooling.

2. Cuatro etapas residuales

Las etapas suelen identificarse como:

• Layer1.
• Layer2.
• Layer3.
• Layer4.

En la nomenclatura del artículo original también aparecen nombres como conv2_x, conv3_x, conv4_x y conv5_x.

3. Reducción espacial

Al avanzar entre determinadas etapas, la resolución espacial disminuye.

Al mismo tiempo, normalmente aumenta el número de canales.

4. Global Average Pooling

Las características espaciales finales se agregan en una representación compacta.

5. Capa de clasificación

Una capa completamente conectada transforma la representación final en puntuaciones de clase o logits.

Flujo general

Imagen → Convolución inicial → Etapas residuales → Global Average Pooling → Clasificador

¿Qué es una Convolución en ResNet?

Una convolución aplica filtros aprendibles sobre regiones de una imagen o mapa de características.

Ejemplo

Una imagen tiene dimensiones:

224 × 224 × 3

Una convolución utiliza filtros que procesan información local.

Las salidas pueden representar:

• Bordes.
• Texturas.
• Formas.
• Patrones espaciales.
• Combinaciones de características.

Las capas posteriores pueden aprender representaciones progresivamente más abstractas.

¿ResNet utiliza solamente convoluciones?

No.

También utiliza sumas residuales, normalización, activaciones, pooling y una cabeza de clasificación.

¿Qué es un Feature Map?

Un Feature Map es una representación producida por una capa neuronal, especialmente una convolución.

En PyTorch, una representación de imagen suele tener forma:

[Batch, Channels, Height, Width]

Por ejemplo:

[8, 64, 56, 56]

Esto significa:

• Ocho imágenes.
• Sesenta y cuatro canales.
• Altura espacial de 56.
• Anchura espacial de 56.

¿Por qué importa?

Las sumas residuales requieren que las representaciones de ambas ramas tengan dimensiones compatibles.

¿Qué es un BasicBlock?

Un BasicBlock es un tipo de bloque residual utilizado en variantes como ResNet-18 y ResNet-34.

Una estructura clásica contiene:

1. Convolución de 3 × 3.
2. Batch Normalization.
3. ReLU.
4. Segunda convolución de 3 × 3.
5. Batch Normalization.
6. Suma con shortcut.
7. ReLU posterior.

Fórmula

y = ReLU(F(x) + S(x))

Donde S(x) representa la shortcut.

Si las dimensiones coinciden:

S(x) = x

Si no coinciden, puede utilizarse una proyección.

¿Qué significa?

El bloque aprende una transformación convolucional adicional y la combina con una ruta paralela.

¿Qué es un Bottleneck Block?

Un Bottleneck Block utiliza habitualmente tres convoluciones principales:

1 × 1 → 3 × 3 → 1 × 1

Primera convolución: 1 × 1

Puede modificar o reducir el número de canales internos.

Segunda convolución: 3 × 3

Procesa relaciones espaciales entre características.

Tercera convolución: 1 × 1

Expande los canales hasta la dimensión requerida por la salida.

¿Por qué utilizar Bottleneck?

Permite construir determinados bloques profundos con una organización eficiente de canales y operaciones.

¿Dónde aparece?

Es habitual en:

• ResNet-50.
• ResNet-101.
• ResNet-152.

¿Por qué no utilizar siempre BasicBlock?

Las dos estructuras tienen propiedades computacionales y arquitectónicas diferentes.

La elección depende de la profundidad y de la configuración deseada.

BasicBlock frente a Bottleneck

¿Qué significa expansión 4?

En la implementación habitual de torchvision, Bottleneck genera una salida con cuatro veces los canales internos de referencia del bloque.

No significa que cada convolución aumente cuatro veces los canales.

¿Qué variantes de ResNet existen?

Las variantes clásicas se diferencian en profundidad, distribución de bloques y tipo de bloque.

Valores redondeados de configuraciones habituales de clasificación ImageNet con 1.000 clases. Pueden cambiar al sustituir la cabeza de clasificación o modificar la arquitectura.

ResNet-18

Es una de las variantes relativamente ligeras de la familia.

Puede resultar útil para:

• Aprendizaje.
• Prototipos.
• Experimentos con recursos limitados.
• Transfer Learning en tareas sencillas.

ResNet-34

Incorpora más bloques básicos que ResNet-18.

Puede representar una alternativa intermedia cuando se requiere mayor profundidad.

ResNet-50

Utiliza Bottleneck Blocks.

Es una arquitectura ampliamente utilizada como referencia en tareas de visión.

Puede ser un buen punto de partida para Transfer Learning.

ResNet-101

Contiene más bloques profundos y requiere mayor capacidad de cálculo.

ResNet-152

Es una variante considerablemente más profunda.

Su utilización requiere evaluar si la posible mejora justifica el coste de entrenamiento e inferencia.

¿Una ResNet más profunda siempre tiene mayor precisión?

No.

El rendimiento depende del entrenamiento, el dataset, el tamaño de las imágenes y los pesos disponibles.

Una ResNet-50 bien entrenada puede superar a una ResNet-101 entrenada de forma inadecuada.

¿Cómo se calcula la profundidad de ResNet?

En las convenciones de las arquitecturas clásicas, se cuentan las capas principales con pesos, como las convoluciones y la capa final de clasificación.

Por ejemplo, ResNet-18 contiene:

• Una convolución inicial.
• Ocho BasicBlocks con dos convoluciones cada uno.
• Una capa completamente conectada final.

Por tanto:

1 + (8 × 2) + 1 = 18

¿Y ResNet-50?

Contiene dieciséis Bottleneck Blocks con tres convoluciones principales:

1 + (16 × 3) + 1 = 50

Precaución

Las convoluciones de proyección de las shortcuts pueden introducir parámetros adicionales sin cambiar la denominación convencional de profundidad.

¿Cómo se modifican las dimensiones espaciales?

Tomemos una ResNet-50 clásica con entrada de 224 × 224 píxeles.

¿Por qué disminuye la resolución?

La arquitectura realiza operaciones de reducción espacial en determinadas etapas.

Esto permite agregar información de regiones progresivamente mayores.

¿Por qué aumentan los canales?

Porque el modelo puede construir más tipos de características a medida que procesa representaciones más abstractas.

¿Son estas dimensiones universales?

No.

Pueden variar con la resolución de entrada y las modificaciones arquitectónicas.

¿Qué es una Projection Shortcut?

Una Projection Shortcut adapta la entrada de un bloque cuando cambian los canales o la resolución espacial.

Por ejemplo, en PyTorch puede utilizarse una convolución de 1 × 1 con un stride apropiado.

Fórmula

y = F(x) + P(x)

Donde P representa la proyección.

¿Por qué no podemos sumar directamente tensores diferentes?

La suma residual necesita representaciones compatibles.

Por ejemplo:

[8, 64, 56, 56]

no puede sumarse directamente con:

[8, 128, 28, 28]

sin una transformación adecuada.

Solución habitual

Una proyección puede modificar canales y resolución para que ambas ramas coincidan.

Ejemplo 1 — Operación residual con NumPy

Comenzaremos con un ejemplo sencillo.

import numpy as np
x = np.array([
    1.0,
    2.0,
    3.0
])
W = np.array([
    [0.1, 0.0, 0.0],
    [0.0, 0.2, 0.0],
    [0.0, 0.0, 0.3]
])
residual = W @ x
output = x + residual
print("Entrada:", x)
print("Residual:", residual)
print("Salida:", output)

¿Qué demuestra?

El bloque aprende o aplica una transformación F(x) y conserva una ruta directa para x.

Limitación

El ejemplo utiliza una transformación lineal fija y no representa las convoluciones de ResNet.

Su finalidad es explicar la suma residual.

Ejemplo 2 — Crear un BasicBlock en PyTorch

Construiremos un bloque convolucional residual.

import torch
import torch.nn as nn
class BasicBlock(nn.Module):
    def __init__(
        self,
        in_channels,
        out_channels,
        stride=1
    ):
        super().__init__()
        self.conv1 = nn.Conv2d(
            in_channels,
            out_channels,
            kernel_size=3,
            stride=stride,
            padding=1,
            bias=False
        )
        self.bn1 = nn.BatchNorm2d(
            out_channels
        )
        self.relu = nn.ReLU(
            inplace=True
        )
        self.conv2 = nn.Conv2d(
            out_channels,
            out_channels,
            kernel_size=3,
            padding=1,
            bias=False
        )
        self.bn2 = nn.BatchNorm2d(
            out_channels
        )
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(
                    in_channels,
                    out_channels,
                    kernel_size=1,
                    stride=stride,
                    bias=False
                ),
                nn.BatchNorm2d(
                    out_channels
                )
            )
        else:
            self.shortcut = nn.Identity()
    def forward(self, x):
        identity = self.shortcut(x)
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)
        out = out + identity
        return self.relu(out)
block = BasicBlock(
    in_channels=64,
    out_channels=128,
    stride=2
)
X = torch.randn(
    4, 64, 56, 56
)
Y = block(X)
print("Entrada:", X.shape)
print("Salida:", Y.shape)

Resultado esperado

Entrada:

[4, 64, 56, 56]

Salida:

[4, 128, 28, 28]

¿Qué demuestra?

La rama principal reduce la resolución espacial y cambia el número de canales.

La shortcut aplica una proyección compatible.

Finalmente, ambas ramas se suman.

Ejemplo 3 — Crear un Bottleneck Block en PyTorch

Ahora implementaremos un bloque con tres convoluciones.

import torch
import torch.nn as nn
class BottleneckBlock(nn.Module):
    expansion = 4
    def __init__(
        self,
        in_channels,
        bottleneck_channels,
        stride=1
    ):
        super().__init__()
        out_channels = (
            bottleneck_channels * self.expansion
        )
        self.main = nn.Sequential(
            nn.Conv2d(
                in_channels,
                bottleneck_channels,
                kernel_size=1,
                bias=False
            ),
            nn.BatchNorm2d(
                bottleneck_channels
            ),
            nn.ReLU(inplace=True),
            nn.Conv2d(
                bottleneck_channels,
                bottleneck_channels,
                kernel_size=3,
                stride=stride,
                padding=1,
                bias=False
            ),
            nn.BatchNorm2d(
                bottleneck_channels
            ),
            nn.ReLU(inplace=True),
            nn.Conv2d(
                bottleneck_channels,
                out_channels,
                kernel_size=1,
                bias=False
            ),
            nn.BatchNorm2d(
                out_channels
            )
        )
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(
                    in_channels,
                    out_channels,
                    kernel_size=1,
                    stride=stride,
                    bias=False
                ),
                nn.BatchNorm2d(
                    out_channels
                )
            )
        else:
            self.shortcut = nn.Identity()
        self.relu = nn.ReLU(
            inplace=True
        )
    def forward(self, x):
        return self.relu(
            self.main(x)
            + self.shortcut(x)
        )
block = BottleneckBlock(
    in_channels=256,
    bottleneck_channels=128,
    stride=2
)
X = torch.randn(
    4, 256, 56, 56
)
Y = block(X)
print(Y.shape)

Resultado esperado

[4, 512, 28, 28]

¿Qué demuestra?

La rama Bottleneck utiliza una expansión de cuatro veces los canales internos.

La shortcut mantiene la compatibilidad dimensional.

Nota técnica

El ejemplo sigue una disposición habitual de stride en la convolución 3 × 3, como en implementaciones modernas de torchvision. Existen diferencias históricas entre variantes ResNet y la ubicación del stride puede modificar los resultados y la compatibilidad de pesos.

Ejemplo 4 — Crear las variantes de ResNet con torchvision

PyTorch dispone de implementaciones listas para utilizar.

Instalación

pip install torch torchvision

Código

from torchvision.models import (
    resnet18,
    resnet34,
    resnet50,
    resnet101,
    resnet152
)
models = {
    "ResNet-18": resnet18(weights=None),
    "ResNet-34": resnet34(weights=None),
    "ResNet-50": resnet50(weights=None),
    "ResNet-101": resnet101(weights=None),
    "ResNet-152": resnet152(weights=None)
}
for name, model in models.items():
    parameters = sum(
        p.numel()
        for p in model.parameters()
    )
    print(
        name,
        f"{parameters / 1_000_000:.2f} M"
    )

¿Qué demuestra?

Permite comparar el número de parámetros de las distintas variantes.

¿Qué significa weights=None?

La arquitectura se construye sin descargar pesos preentrenados.

Precaución

El número de parámetros no representa por sí solo:

• Calidad predictiva.
• Velocidad de inferencia.
• Consumo total de memoria.
• Coste de entrenamiento.
• Rendimiento en hardware específico.

¿Qué es Transfer Learning con ResNet?

Transfer Learning es un procedimiento que reutiliza representaciones aprendidas anteriormente para resolver una nueva tarea.

Una ResNet preentrenada puede haber aprendido características visuales útiles a partir de un gran dataset.

Ejemplo

Disponemos de una ResNet-50 preentrenada en ImageNet.

Queremos clasificar imágenes en tres categorías:

• Electrónica.
• Mobiliario.
• Equipamiento industrial.

En lugar de entrenar toda la red desde cero, podemos reutilizar sus representaciones y sustituir el clasificador final.

¿Por qué puede funcionar?

Porque determinadas características visuales aprendidas previamente pueden transferirse a nuevas tareas.

¿Está garantizado?

No.

El rendimiento depende de la similitud entre los dominios, la cantidad de datos disponibles y la relevancia de las representaciones.

¿Qué significa Freezing Layers?

Freezing Layers significa congelar parámetros durante entrenamiento.

En PyTorch podemos utilizar:

parameter.requires_grad = False

¿Qué ocurre?

El parámetro no recibe actualizaciones de gradiente durante el entrenamiento convencional.

¿Por qué congelar capas?

Para reutilizar un extractor de características sin modificar sus pesos.

¿Qué podemos entrenar?

Una nueva cabeza de clasificación.

Precaución

Congelar parámetros no equivale a poner automáticamente BatchNorm en modo evaluación.

El comportamiento de las estadísticas de BatchNorm debe gestionarse por separado.

Ejemplo 5 — Transfer Learning con ResNet-18 en PyTorch

Vamos a crear un clasificador de tres categorías.

import torch
import torch.nn as nn
from torchvision.models import (
    resnet18,
    ResNet18_Weights
)
weights = ResNet18_Weights.DEFAULT
model = resnet18(
    weights=weights
)
# Congelar extractor
for parameter in model.parameters():
    parameter.requires_grad = False
# Sustituir capa de salida
input_features = model.fc.in_features
model.fc = nn.Linear(
    input_features,
    3
)
optimizer = torch.optim.AdamW(
    model.fc.parameters(),
    lr=0.001,
    weight_decay=0.01
)
criterion = nn.CrossEntropyLoss()
print(model.fc)

¿Qué demuestra?

La arquitectura conserva las características preentrenadas.

La nueva cabeza tiene tres salidas.

¿Qué necesitamos para entrenar?

• Imágenes etiquetadas.
• DataLoader de entrenamiento.
• DataLoader de validación.
• Transformaciones correctas.
• Función de pérdida.
• Evaluación independiente.

Nota importante

La primera ejecución con pesos preentrenados puede necesitar descargar archivos. Si el entorno no tiene acceso a Internet, será necesario disponer previamente de esos pesos.

¿Cómo preparar imágenes para una ResNet preentrenada?

Los pesos preentrenados se obtuvieron utilizando determinados procedimientos de preprocesamiento.

Por eso es importante emplear las transformaciones adecuadas.

Torchvision ofrece:

preprocess = weights.transforms()

Ejemplo

from PIL import Image
image = Image.open(
    "producto.jpg"
).convert("RGB")
tensor = preprocess(
    image
).unsqueeze(0)
print(tensor.shape)

Resultado habitual

[1, 3, 224, 224]

¿Qué demuestra?

La imagen se convierte en un tensor con las dimensiones y normalización esperadas por los pesos.

Precaución

No debemos asumir que todos los modelos y versiones de pesos utilizan exactamente las mismas transformaciones.

Conviene recuperar las transformaciones desde el objeto weights.

Ejemplo 6 — Inferencia con una ResNet preentrenada

Vamos a realizar una clasificación ImageNet.

import torch
from PIL import Image
from torchvision.models import (
    resnet18,
    ResNet18_Weights
)
weights = ResNet18_Weights.DEFAULT
model = resnet18(
    weights=weights
)
model.eval()
preprocess = weights.transforms()
image = Image.open(
    "producto.jpg"
).convert("RGB")
X = preprocess(
    image
).unsqueeze(0)
with torch.inference_mode():
    logits = model(X)
    probabilities = torch.softmax(
        logits,
        dim=1
    )
    class_id = probabilities.argmax(
        dim=1
    ).item()
label = weights.meta["categories"][class_id]
confidence = probabilities[0, class_id].item()
print("Clase:", label)
print("Probabilidad Softmax:", confidence)

¿Qué demuestra?

El modelo produce logits para las categorías ImageNet correspondientes a los pesos cargados.

Después se calculan probabilidades Softmax.

Precaución

La probabilidad Softmax no debe interpretarse automáticamente como una confianza perfectamente calibrada.

Además, un producto que no pertenece claramente a las categorías aprendidas puede recibir una clasificación poco apropiada.

Ejemplo 7 — Fine-Tuning completo de ResNet-18

El siguiente ejemplo muestra un procedimiento de entrenamiento para imágenes organizadas en carpetas.

Estructura del dataset

dataset/
    train/
        electronica/
        mobiliario/
        industrial/
    val/
        electronica/
        mobiliario/
        industrial/
    test/
        electronica/
        mobiliario/
        industrial/

Las carpetas deben contener imágenes reales y las clases deben ser coherentes entre particiones.

Código completo

import copy
import math
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torchvision.models import (
    resnet18,
    ResNet18_Weights
)
device = torch.device(
    "cuda" if torch.cuda.is_available() else "cpu"
)
torch.manual_seed(42)
weights = ResNet18_Weights.DEFAULT
# Transformaciones para imágenes
eval_transform = weights.transforms()
# Para un baseline reproducible:
# se utiliza la misma transformación en train.
# En producción puede añadirse Data Augmentation
# únicamente al conjunto de entrenamiento.
train_transform = eval_transform
train_dataset = datasets.ImageFolder(
    "dataset/train",
    transform=train_transform
)
val_dataset = datasets.ImageFolder(
    "dataset/val",
    transform=eval_transform
)
test_dataset = datasets.ImageFolder(
    "dataset/test",
    transform=eval_transform
)
assert train_dataset.classes == val_dataset.classes
assert train_dataset.classes == test_dataset.classes
num_classes = len(train_dataset.classes)
generator = torch.Generator()
generator.manual_seed(42)
train_loader = DataLoader(
    train_dataset,
    batch_size=16,
    shuffle=True,
    generator=generator,
    num_workers=0
)
val_loader = DataLoader(
    val_dataset,
    batch_size=16,
    shuffle=False,
    num_workers=0
)
test_loader = DataLoader(
    test_dataset,
    batch_size=16,
    shuffle=False,
    num_workers=0
)
# 1. Crear ResNet preentrenada
model = resnet18(weights=weights)
# 2. Sustituir clasificador
features = model.fc.in_features
model.fc = nn.Linear(
    features,
    num_classes
)
model = model.to(device)
criterion = nn.CrossEntropyLoss()
# 3. Entrenamiento en dos grupos
backbone_params = [
    p for name, p in model.named_parameters()
    if not name.startswith("fc.")
]
optimizer = torch.optim.AdamW(
    [
        {
            "params": backbone_params,
            "lr": 1e-5
        },
        {
            "params": model.fc.parameters(),
            "lr": 1e-3
        }
    ],
    weight_decay=0.01
)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
    optimizer,
    T_max=15
)
def evaluate(loader):
    model.eval()
    total_loss = 0.0
    total_correct = 0
    total_examples = 0
    with torch.inference_mode():
        for images, labels in loader:
            images = images.to(device)
            labels = labels.to(device)
            logits = model(images)
            loss = criterion(
                logits,
                labels
            )
            count = labels.size(0)
            total_loss += loss.item() * count
            predictions = logits.argmax(
                dim=1
            )
            total_correct += (
                predictions == labels
            ).sum().item()
            total_examples += count
    if total_examples == 0:
        raise RuntimeError("Dataset vacío.")
    return (
        total_loss / total_examples,
        total_correct / total_examples
    )
best_val_loss = float("inf")
best_state = None
best_epoch = None
patience = 5
wait = 0
for epoch in range(1, 16):
    model.train()
    total_loss = 0.0
    total_examples = 0
    for images, labels in train_loader:
        images = images.to(device)
        labels = labels.to(device)
        optimizer.zero_grad()
        logits = model(images)
        loss = criterion(
            logits,
            labels
        )
        loss.backward()
        torch.nn.utils.clip_grad_norm_(
            model.parameters(),
            max_norm=5.0
        )
        optimizer.step()
        count = labels.size(0)
        total_loss += (
            loss.item() * count
        )
        total_examples += count
    train_loss = (
        total_loss / total_examples
    )
    val_loss, val_accuracy = evaluate(
        val_loader
    )
    print(
        f"Epoch {epoch:02d} | "
        f"Train Loss={train_loss:.4f} | "
        f"Val Loss={val_loss:.4f} | "
        f"Val Accuracy={val_accuracy:.3f}"
    )
    if not math.isfinite(val_loss):
        raise RuntimeError(
            "Validation Loss no finita."
        )
    if val_loss < best_val_loss - 0.0001:
        best_val_loss = val_loss
        best_state = copy.deepcopy(
            model.state_dict()
        )
        best_epoch = epoch
        wait = 0
    else:
        wait += 1
    if wait >= patience:
        break
    scheduler.step()
# 4. Restaurar mejor modelo
if best_state is None:
    raise RuntimeError(
        "No existe un checkpoint válido."
    )
model.load_state_dict(best_state)
# 5. Test independiente
test_loss, test_accuracy = evaluate(
    test_loader
)
print("Mejor época:", best_epoch)
print("Test Loss:", test_loss)
print("Test Accuracy:", test_accuracy)
# 6. Guardar pesos seleccionados
torch.save(
    model.state_dict(),
    "resnet18_custom_classifier.pt"
)

¿Qué demuestra?

El ejemplo implementa un procedimiento completo:

• Carga de imágenes.
• Verificación de etiquetas.
• Transfer Learning.
• Fine-Tuning de backbone y cabeza con tasas diferentes.
• Clipping de gradientes.
• Cosine Annealing.
• Early Stopping.
• Restauración de mejores pesos.
• Evaluación independiente.

¿Es necesario utilizar esas Learning Rates?

No.

Los valores son ilustrativos.

Deben seleccionarse mediante validación.

Advertencia sobre BatchNorm

El código realiza Fine-Tuning completo y permite actualizar las estadísticas de BatchNorm durante entrenamiento.

En datasets pequeños, esto puede producir resultados variables.

Una alternativa consiste en congelar temporalmente el backbone y entrenar primero la cabeza.

También puede evaluarse mantener BatchNorm en modo evaluación durante determinadas etapas.

¿El clipping de 5.0 es obligatorio?

No.

Se incluye como ejemplo de integración.

Debe utilizarse solamente cuando exista una justificación experimental.

Precaución sobre los datos

La partición debe evitar fugas de información.

Por ejemplo, fotografías casi idénticas de un mismo producto no deberían repartirse arbitrariamente entre Train y Test cuando se desea medir generalización a productos nuevos.

¿Qué diferencia existe entre Feature Extraction y Fine-Tuning?

Ambos procedimientos reutilizan modelos preentrenados.

Feature Extraction

El backbone se congela.

Se entrena principalmente la nueva cabeza.

Ventajas potenciales

• Menor coste de entrenamiento.
• Menor número de parámetros actualizados.
• Adecuado para determinados datasets pequeños.

Fine-Tuning

Se actualizan algunas o todas las capas del backbone.

Ventajas potenciales

• Adaptación a nuevas características visuales.
• Mayor flexibilidad.

Riesgos

• Overfitting.
• Mayor consumo de recursos.
• Deterioro de características útiles.
• Sensibilidad a Learning Rate.

¿Cuál conviene utilizar?

Es frecuente comenzar con Feature Extraction y después evaluar Fine-Tuning parcial o completo.

ResNet en Keras

Keras dispone de implementaciones de diferentes arquitecturas ResNet.

Entre ellas encontramos:

• keras.applications.ResNet50
• keras.applications.ResNet101
• keras.applications.ResNet152
• keras.applications.ResNet50V2
• keras.applications.ResNet101V2
• keras.applications.ResNet152V2

Las variantes V2 incorporan modificaciones relacionadas con la disposición de activación y normalización.

Ejemplo 8 — Crear ResNet-50 en Keras

import keras
model = keras.applications.ResNet50(
    include_top=True,
    weights=None,
    classes=3,
    classifier_activation=None
)
model.summary()

¿Qué demuestra?

Construye una ResNet-50 para tres categorías con inicialización aleatoria.

¿Por qué classifier_activation=None?

Permite obtener logits.

¿Por qué weights=None?

Porque estamos creando una nueva cabeza dentro de un modelo no preentrenado.

¿Se puede cargar ImageNet con tres clases directamente?

Para reutilizar pesos ImageNet y cambiar el número de clases, normalmente se construye el backbone sin la cabeza original y se añade una cabeza nueva.

Ejemplo 9 — Transfer Learning con ResNet-50 en Keras

import keras
from keras import layers
# Backbone con pesos preentrenados
base = keras.applications.ResNet50(
    include_top=False,
    weights="imagenet",
    input_shape=(224, 224, 3),
    pooling="avg"
)
# Congelar extractor
base.trainable = False
inputs = keras.Input(
    shape=(224, 224, 3)
)
# Valores RGB en rango 0-255
x = keras.applications.resnet.preprocess_input(
    inputs
)
# Evita actualizar estadísticas de BatchNorm
x = base(
    x,
    training=False
)
x = layers.Dropout(0.2)(x)
outputs = layers.Dense(
    3
)(x)
model = keras.Model(
    inputs,
    outputs
)
model.compile(
    optimizer=keras.optimizers.AdamW(
        learning_rate=0.001
    ),
    loss=keras.losses.SparseCategoricalCrossentropy(
        from_logits=True
    ),
    metrics=["accuracy"]
)
model.summary()

¿Qué demuestra?

El modelo reutiliza un extractor de características visuales preentrenado en ImageNet y añade una cabeza de tres clases.

¿Por qué training=False en el backbone?

Para conservar el comportamiento de inferencia de sus capas de BatchNorm, especialmente útil durante la etapa de extracción congelada.

¿Qué ocurre si deseamos Fine-Tuning posterior?

Podemos descongelar determinadas capas, recompilar el modelo con una Learning Rate menor y continuar el entrenamiento.

Conviene mantener especial atención a BatchNorm.

¿Por qué el preprocesamiento de Keras y torchvision es diferente?

Una diferencia importante entre frameworks es que sus modelos preentrenados pueden utilizar convenciones diferentes.

Keras ResNet clásica

keras.applications.resnet.preprocess_input convierte los canales RGB a BGR y aplica centrado con estadísticas de ImageNet sin escalar inicialmente los píxeles al intervalo 0–1.

Keras ResNetV2

Utiliza otra convención que escala las entradas a un intervalo centrado aproximadamente entre −1 y 1.

Torchvision ResNet

El objeto de pesos ofrece sus propias transformaciones, que incluyen el procedimiento previsto para ese conjunto de pesos.

Conclusión

No debemos intercambiar arbitrariamente el preprocesamiento de una ResNet Keras con el de una ResNet torchvision.

La arquitectura puede ser similar, pero las convenciones de entrada y los pesos no son necesariamente compatibles.

¿Qué es ResNetV2?

ResNetV2 es una familia de variantes que utiliza una organización de preactivación en bloques residuales.

En términos conceptuales, modifica la posición de Batch Normalization y las funciones de activación.

¿Por qué se desarrolló?

Para estudiar y mejorar las propiedades de propagación de información y gradientes.

¿ResNetV2 es solamente una ResNet más profunda?

No.

La diferencia principal está en la organización interna de los bloques.

¿Puede mejorar entrenamiento?

Puede hacerlo bajo determinadas configuraciones.

La mejora no está garantizada en todos los datasets.

¿Qué diferencia existe entre ResNet y Vision Transformer?

ResNet es principalmente una arquitectura convolucional.

Vision Transformer (ViT) utiliza mecanismos de atención sobre representaciones de imágenes.

Comparación

¿Cuál es mejor?

Depende de:

• Dataset.
• Disponibilidad de pesos.
• Presupuesto de entrenamiento.
• Tamaño de imagen.
• Latencia.
• Hardware.
• Necesidades de despliegue.

No existe una superioridad universal.

ResNet frente a EfficientNet y MobileNet

ResNet no es la única familia de arquitecturas visuales.

MobileNet

Prioriza diseños eficientes para distintos entornos con limitaciones computacionales.

EfficientNet

Explora estrategias de escalado y diseños eficientes para clasificación visual.

ResNet

Es una arquitectura de referencia muy utilizada por su estructura residual y disponibilidad de implementaciones y pesos.

¿Cuál elegir?

Para proyectos pequeños puede ser útil comparar una ResNet-18 con modelos más ligeros.

Para aplicaciones de producción conviene medir:

• Latencia real.
• Precisión.
• Memoria.
• Tamaño de archivos.
• Facilidad de despliegue.

¿Cómo evaluar una ResNet correctamente?

No debemos basarnos únicamente en Training Accuracy.

Métricas útiles

• Accuracy.
• Precision.
• Recall.
• Macro-F1.
• Matriz de confusión.
• Calibration Error cuando corresponda.
• Latencia por imagen.
• Uso de memoria.
• Throughput.
• Tamaño de modelo.

¿Qué ocurre con clases desequilibradas?

Accuracy puede ocultar errores en clases minoritarias.

Conviene evaluar métricas por clase.

¿Qué ocurre con productos visualmente parecidos?

Es posible que se necesite un análisis de errores específico.

Por ejemplo, productos de distintas marcas pueden tener formas muy similares.

¿Qué es Data Augmentation para ResNet?

Data Augmentation modifica las imágenes de entrenamiento para introducir variaciones controladas.

Ejemplos

• Random Crop.
• Horizontal Flip.
• Rotación moderada.
• Cambios de brillo.
• Cambios de contraste.
• Transformaciones geométricas apropiadas.

¿Por qué puede ayudar?

Permite que el modelo observe variaciones de las imágenes durante entrenamiento.

Precaución

No todas las transformaciones conservan las etiquetas.

Por ejemplo, una rotación o un recorte extremo podría eliminar un logotipo importante.

Buena práctica

Aplicar augmentation principalmente en entrenamiento y mantener un procedimiento determinista para validación y prueba.

¿Qué es una Confusion Matrix?

Una Matriz de Confusión permite comparar clases reales con clases predichas.

Ejemplo

Un clasificador distingue tres categorías de productos.

La matriz puede mostrar qué categorías se confunden con mayor frecuencia.

¿Por qué es útil?

Porque una misma Accuracy puede esconder distintos patrones de errores.

Ejemplo con scikit-learn

from sklearn.metrics import (
    confusion_matrix,
    classification_report
)
# y_true y y_pred deben contener
# las etiquetas reales y predichas
matrix = confusion_matrix(
    y_true,
    y_pred
)
print(matrix)
print(
    classification_report(
        y_true,
        y_pred,
        zero_division=0
    )
)

Nota

Este fragmento presupone que y_true y y_pred ya se han calculado durante la evaluación.

¿Cuánta memoria necesita ResNet?

El consumo depende de:

• Número de parámetros.
• Precisión numérica.
• Batch Size.
• Resolución de imagen.
• Activaciones almacenadas.
• Estados del optimizador.
• Framework.
• Hardware.

Ejemplo

ResNet-50 tiene aproximadamente 25,6 millones de parámetros en su configuración habitual de clasificación ImageNet.

Si los parámetros están representados en float32:

25,6 millones × 4 bytes ≈ 102,4 MB

Esto representa solamente la memoria aproximada de parámetros.

¿Es la memoria total de entrenamiento?

No.

Durante entrenamiento también pueden almacenarse:

• Gradientes.
• Estados del optimizador.
• Activaciones.
• Buffers.
• Tensores temporales.

El consumo total puede ser considerablemente mayor.

¿ResNet necesita GPU?

No.

Una ResNet puede ejecutarse en CPU.

Sin embargo, el entrenamiento y la inferencia sobre grandes conjuntos de imágenes suelen beneficiarse de aceleradores compatibles.

¿Qué variante utilizar con recursos limitados?

ResNet-18 puede ser un punto de partida razonable.

¿Qué ocurre con ResNet-152?

Es más profunda y puede requerir más memoria y tiempo.

¿Es obligatorio utilizar la versión más profunda?

No.

La elección debe responder a requisitos medidos.

ResNet y Fine-Tuning con pocos datos

Cuando disponemos de pocas imágenes, podemos utilizar pesos preentrenados.

Estrategia inicial

Congelar el backbone y entrenar una cabeza pequeña.

Segunda etapa

Descongelar una parte de las últimas capas.

Tercera etapa

Evaluar si conviene realizar Fine-Tuning más amplio.

Precaución

Los datasets pequeños pueden presentar Overfitting y resultados muy variables.

Conviene mantener particiones independientes, evitar duplicados y utilizar varias semillas cuando sea posible.

¿Por qué ResNet importa para AI Visibility?

Los sistemas de AI Visibility no trabajan necesariamente solo con texto.

También pueden analizar activos visuales relacionados con marcas.

Por ejemplo:

• Logotipos.
• Imágenes de productos.
• Fotografías comerciales.
• Capturas de sitios web.
• Elementos visuales de fichas de productos.
• Creatividades promocionales.

Una ResNet puede utilizarse como extractor de características visuales para determinadas tareas.

Ejemplo empresarial

Una empresa quiere identificar si una colección de imágenes contiene productos de su categoría comercial.

Puede entrenar un clasificador utilizando representaciones extraídas de una ResNet preentrenada.

¿Puede detectar directamente la mención de una marca en un texto?

No por sí sola.

Para identificar nombres escritos se necesitaría un procedimiento de OCR o reconocimiento de texto apropiado, y para interpretar recomendaciones habría que incorporar análisis lingüístico.

¿ResNet reconoce automáticamente todos los logotipos?

No.

Un modelo preentrenado en ImageNet no debe considerarse un sistema universal de reconocimiento de marcas.

Se necesitan datasets relevantes y evaluación específica.

Ejemplo 10 — Clasificador visual para activos de marca

Supongamos que tenemos tres categorías:

Logotipo

Imagen de producto

Captura web

Podemos adaptar una ResNet-18 preentrenada.

import torch.nn as nn
from torchvision.models import (
    resnet18,
    ResNet18_Weights
)
weights = ResNet18_Weights.DEFAULT
model = resnet18(
    weights=weights
)
for parameter in model.parameters():
    parameter.requires_grad = False
num_features = model.fc.in_features
model.fc = nn.Sequential(
    nn.Dropout(0.2),
    nn.Linear(
        num_features,
        3
    )
)
optimizer = torch.optim.AdamW(
    model.fc.parameters(),
    lr=0.001
)
print(model.fc)

¿Qué demuestra?

La red utiliza las representaciones visuales aprendidas previamente y adapta la última capa a una nueva clasificación.

¿Es un sistema validado de AI Visibility?

No.

Necesita imágenes reales, etiquetas, entrenamiento y validación.

Precaución

Las categorías del ejemplo describen tipos de activos visuales.

No representan directamente Recommendation Rate, Citation Coverage ni otras métricas de visibilidad textual.

ResNet y OCR

El reconocimiento óptico de caracteres (OCR) convierte imágenes de texto en representaciones textuales.

¿Es ResNet un sistema OCR completo?

No.

ResNet puede utilizarse como backbone visual dentro de determinados sistemas de reconocimiento de texto.

Pero el sistema completo necesita otros componentes para localizar, reconocer y estructurar caracteres o palabras.

¿Por qué puede ser útil?

Las capas convolucionales pueden aprender características visuales relevantes.

Precaución

Reconocer el contenido escrito y comprender su significado son tareas diferentes.

ResNet y sistemas multimodales

Un sistema multimodal puede combinar información visual y textual.

Ejemplo

Un sistema recibe:

• Una imagen de producto.
• Una descripción comercial.
• Una pregunta sobre la categoría.

Una ResNet puede participar como extractor visual.

Un componente adicional procesa el texto.

Posteriormente, el sistema combina ambas representaciones.

¿Es ResNet una arquitectura multimodal completa?

No.

Es un componente visual que puede integrarse en un diseño multimodal.

ResNet y gradientes desvanecientes

Las conexiones residuales fueron importantes para mejorar la optimización de redes profundas.

¿Cómo ayudan?

Proporcionan rutas adicionales para transmitir gradientes.

Fórmula

y = x + F(x)

El Jacobiano es:

∂y/∂x = I + JF(x)

¿Qué aporta?

La contribución identidad puede favorecer la propagación de señales.

¿Elimina Vanishing Gradients?

No de forma universal.

El comportamiento sigue dependiendo de las transformaciones, las normalizaciones y los parámetros.

ResNet y gradientes explosivos

Aunque ResNet incorpora rutas de identidad, también puede presentar gradientes grandes.

¿Por qué?

Los productos de Jacobianos residuales todavía pueden amplificar determinadas direcciones.

Medidas posibles

• Inicialización apropiada.
• Learning Rate adecuada.
• Normalización.
• Gradient Clipping cuando se justifique.
• Monitorización.

¿Gradient Clipping es obligatorio?

No.

Debe evaluarse según el comportamiento real.

Errores frecuentes al utilizar ResNet

Error 1. Confundir ResNet con una única arquitectura

Es una familia de modelos.

Error 2. Suponer que ResNet-152 siempre supera a ResNet-50

La profundidad no garantiza mejor rendimiento.

Error 3. Confundir BasicBlock y Bottleneck

Utilizan estructuras diferentes.

Error 4. Ignorar las Projection Shortcuts

Las dimensiones deben ser compatibles.

Error 5. Utilizar un preprocesamiento incorrecto

Puede perjudicar considerablemente las predicciones.

Error 6. Suponer que pesos preentrenados clasifican cualquier categoría

Dependen del entrenamiento original.

Error 7. Entrenar una cabeza nueva sin modificar la capa final

El número de clases puede ser incorrecto.

Error 8. Confundir congelar parámetros con congelar estadísticas BatchNorm

Son operaciones diferentes.

Error 9. Descongelar toda la red con una Learning Rate excesiva

Puede deteriorar características preentrenadas.

Error 10. Utilizar imágenes duplicadas entre Train y Test

Produce una evaluación potencialmente optimista.

Error 11. Aplicar augmentations incompatibles con la tarea

Puede alterar o eliminar información necesaria.

Error 12. Comparar modelos sin medir latencia y memoria

La precisión no es el único requisito.

Error 13. Confundir ResNetV2 con una variante simplemente más profunda

Modifica la organización de los bloques.

Error 14. Interpretar Softmax como confianza perfectamente calibrada

Las probabilidades pueden no estar bien calibradas.

Error 15. Suponer que ResNet mide directamente la visibilidad de una marca en asistentes de IA

Es principalmente una arquitectura visual.

Buenas prácticas para ResNet

Para desarrollar sistemas fiables conviene:

1. Seleccionar la variante según los recursos.
2. Utilizar pesos preentrenados cuando resulte apropiado.
3. Recuperar el preprocesamiento correspondiente a esos pesos.
4. Separar entrenamiento, validación y prueba.
5. Evitar imágenes duplicadas entre particiones.
6. Verificar la correspondencia entre índices y nombres de clases.
7. Comenzar con un clasificador congelado cuando sea razonable.
8. Evaluar Fine-Tuning progresivo.
9. Controlar BatchNorm.
10. Registrar Learning Rate y Weight Decay.
11. Utilizar augmentations apropiadas.
12. Medir métricas por clase.
13. Monitorizar memoria y latencia.
14. Evaluar varias semillas cuando sea posible.
15. Documentar arquitectura, pesos y versiones de bibliotecas.

En aplicaciones comerciales también conviene comprobar el comportamiento sobre imágenes capturadas en condiciones reales.

Preguntas frecuentes sobre ResNet

¿Qué significa ResNet?

Significa Residual Network o Red Neuronal Residual.

¿Qué es ResNet?

Es una familia de redes neuronales profundas que utiliza bloques residuales.

¿Quién desarrolló ResNet?

Kaiming He, Xiangyu Zhang, Shaoqing Ren y Jian Sun.

¿Cuándo se presentó?

El trabajo original apareció en 2015 y se publicó en CVPR 2016.

¿Cuál es la innovación principal?

El aprendizaje de transformaciones residuales mediante conexiones shortcut.

¿Qué significa Residual Learning?

Aprender una modificación respecto a una representación existente.

¿Cuál es la fórmula básica?

y = x + F(x)

¿Qué es un Residual Block?

Es un bloque que combina una transformación aprendible con una shortcut.

¿Qué es BasicBlock?

Es un bloque residual básico que suele utilizar dos convoluciones 3 × 3.

¿Qué es Bottleneck?

Es un bloque que suele utilizar convoluciones 1 × 1, 3 × 3 y 1 × 1.

¿Qué es Identity Shortcut?

Es una ruta que transmite directamente la entrada.

¿Qué es Projection Shortcut?

Es una ruta que adapta canales o dimensiones antes de la suma residual.

¿Qué es ResNet-18?

Es una variante clásica con dieciocho capas según la convención de conteo.

¿Qué es ResNet-34?

Es una variante que utiliza más BasicBlocks que ResNet-18.

¿Qué es ResNet-50?

Es una variante que utiliza Bottleneck Blocks y cincuenta capas principales.

¿Qué es ResNet-101?

Es una variante más profunda que ResNet-50.

¿Qué es ResNet-152?

Es una variante clásica con 152 capas principales.

¿ResNet-152 es siempre mejor?

No.

¿Qué es una CNN?

Es una red neuronal convolucional utilizada para procesar información estructurada espacialmente.

¿ResNet es una CNN?

Las variantes clásicas de ResNet para visión son redes convolucionales.

¿Qué es un Feature Map?

Es una representación producida por una capa, habitualmente convolucional.

¿Qué es Global Average Pooling?

Es una operación que resume cada canal espacial mediante un promedio.

¿Qué es BatchNorm?

Es una técnica de normalización utilizada en numerosos bloques ResNet.

¿Qué es ResNetV2?

Es una variante residual basada en preactivación.

¿Qué diferencia existe entre ResNet y ResNetV2?

Principalmente la organización de activaciones y normalización dentro de los bloques.

¿ResNet elimina Vanishing Gradients?

No completamente.

¿Puede haber Exploding Gradients en ResNet?

Sí.

¿Qué es Transfer Learning?

Es reutilizar conocimientos o representaciones aprendidos en otra tarea.

¿Qué es Fine-Tuning?

Es adaptar algunos o todos los parámetros de un modelo preentrenado.

¿Qué significa congelar capas?

Significa impedir que determinados parámetros se actualicen durante el entrenamiento.

¿Se puede entrenar solo la última capa?

Sí.

¿Es obligatorio utilizar ImageNet?

No.

Podemos entrenar desde cero o utilizar otros pesos compatibles.

¿Qué es ImageNet?

Es una familia de datasets y benchmarks utilizados ampliamente en reconocimiento visual.

¿Qué significa weights=None?

Construir el modelo sin cargar pesos preentrenados.

¿Qué es ResNet18_Weights.DEFAULT?

Es la selección predeterminada de pesos preentrenados asociada con ResNet-18 en torchvision.

¿Por qué utilizar weights.transforms()?

Para obtener el preprocesamiento correspondiente a esos pesos.

¿ResNet necesita imágenes de 224 × 224?

Es una dimensión habitual para los modelos clásicos, pero las condiciones exactas dependen de arquitectura, pesos e implementación.

¿Se puede utilizar ResNet en PyTorch?

Sí.

¿Se puede utilizar en Keras?

Sí.

¿Se puede utilizar en CPU?

Sí.

¿ResNet necesita GPU?

No, aunque puede beneficiarse de aceleradores.

¿Qué es ResNet-50V2?

Es una variante ResNet-50 con organización de preactivación.

¿Qué diferencia existe entre ResNet y ViT?

ResNet utiliza principalmente convoluciones y ViT utiliza atención sobre representaciones visuales.

¿Qué diferencia existe entre ResNet y MobileNet?

MobileNet prioriza determinados diseños eficientes, mientras que ResNet utiliza bloques residuales clásicos.

¿Qué diferencia existe entre ResNet y EfficientNet?

Sus estrategias de diseño y escalado arquitectónico son diferentes.

¿ResNet sirve para segmentación?

Puede utilizarse como backbone en arquitecturas de segmentación.

¿ResNet sirve para detección de objetos?

Puede emplearse como extractor de características dentro de detectores.

¿ResNet sirve para OCR?

Puede formar parte del extractor visual de ciertos sistemas OCR, pero no constituye por sí sola un sistema OCR completo.

¿ResNet sirve para reconocimiento de logotipos?

Puede adaptarse a esa tarea con datos y etiquetas apropiados.

¿ResNet detecta directamente marcas en respuestas textuales?

No.

¿ResNet aumenta Recommendation Rate?

No directamente.

¿ResNet puede utilizarse en AI Visibility?

Sí, como componente visual en determinadas aplicaciones de análisis de activos de marca.

¿ResNet reemplaza un Transformer de lenguaje?

No.

¿ResNet garantiza mejor precisión?

No.

¿Cómo elegir una variante?

Mediante validación y medición de calidad, latencia, memoria y coste.

Conceptos relacionados

• Inteligencia Artificial: desarrollo de sistemas inteligentes.
• Machine Learning: aprendizaje a partir de datos.
• Deep Learning: redes neuronales profundas.
• Redes Neuronales: modelos con parámetros entrenables.
• Visión por Computadora: análisis automático de imágenes.
• Clasificación: predicción de categorías.
• Aprendizaje por Transferencia: reutilización de modelos.
• Conjuntos de Entrenamiento, Validación y Prueba: evaluación independiente.
• Sobreajuste: adaptación excesiva al entrenamiento.
• Subajuste: aprendizaje insuficiente.
• Regularización: control de complejidad.
• Ajuste de Hiperparámetros: selección de configuraciones.
• Función de Pérdida: cuantificación del error.
• Descenso del Gradiente: actualización de parámetros.
• Tasa de Aprendizaje: magnitud base de actualización.
• Retropropagación: cálculo de gradientes.
• Funciones de Activación: ReLU y otras transformaciones.
• Inicialización de Pesos: condiciones iniciales.
• Normalización por Lotes: Batch Normalization.
• Dropout: regularización estocástica.
• AdamW: optimizador adaptativo.
• Learning Rate Scheduling: programación de la tasa.
• Gradient Clipping: recorte de gradientes.
• Exploding Gradients: gradientes explosivos.
• Vanishing Gradients: gradientes desvanecientes.
• Residual Connections: conexiones residuales.
• ResNet: arquitectura neuronal residual.
• BasicBlock: bloque residual básico.
• Bottleneck: bloque residual con tres convoluciones.
• Projection Shortcut: adaptación de dimensiones.
• Global Average Pooling: agregación espacial.
• ResNetV2: arquitectura de preactivación.
• Transfer Learning: reutilización de características.
• Fine-Tuning: adaptación de parámetros preentrenados.
• ImageNet: conjunto de referencia de reconocimiento visual.
• Vision Transformer: arquitectura visual basada en atención.
• AI Visibility: análisis de presencia y recomendaciones de marcas en sistemas de IA.

Conclusión

La Arquitectura ResNet (Residual Neural Network) representa un avance fundamental en Deep Learning y visión por computadora.

Su principal aportación consiste en utilizar bloques residuales que combinan una transformación aprendible con una conexión shortcut.

Esta estructura facilita el aprendizaje de modificaciones respecto a representaciones existentes y puede mejorar la optimización de redes profundas.

Las variantes ResNet-18, ResNet-34, ResNet-50, ResNet-101 y ResNet-152 ofrecen diferentes configuraciones de profundidad y complejidad.

Las arquitecturas menos profundas utilizan habitualmente BasicBlocks, mientras que las más profundas emplean Bottleneck Blocks.

ResNet también ha demostrado ser especialmente útil para Transfer Learning y Fine-Tuning.

Los modelos preentrenados pueden utilizarse como extractores de características y adaptarse a nuevas categorías de imágenes.

Sin embargo, la profundidad no garantiza mejor calidad.

El rendimiento depende del dataset, el preprocesamiento, la configuración de entrenamiento y la evaluación independiente.

En aplicaciones de AI Visibility, ResNet puede desempeñar un papel útil para analizar imágenes de productos, logotipos y activos visuales relacionados con marcas.

No obstante, el análisis de recomendaciones textuales requiere componentes lingüísticos o multimodales adicionales.

La conclusión fundamental es que ResNet permite construir redes visuales profundas mediante aprendizaje residual, ofreciendo una arquitectura sólida y reutilizable para clasificación, extracción de características y Transfer Learning. Su verdadero valor se obtiene al seleccionar la variante apropiada y validarla sobre datos representativos del problema.