Las Redes Neuronales Convolucionales (Convolutional Neural Networks, CNN) son modelos de aprendizaje profundo especializados en procesar información con una estructura organizada en una o varias dimensiones.

Se utilizan principalmente para analizar imágenes, aunque existen variantes diseñadas para señales temporales, audio, vídeo y otros tipos de datos.

Su principal innovación consiste en aprender filtros que se aplican repetidamente sobre distintas regiones de la entrada.

En lugar de conectar cada píxel con todas las neuronas de la siguiente capa, como sucedería en una red completamente conectada convencional, una CNN puede procesar pequeñas regiones locales mediante parámetros compartidos.

Esta estrategia permite aprovechar propiedades importantes de las imágenes, como la proximidad espacial de los píxeles.

Por ejemplo, una fotografía de un automóvil contiene múltiples patrones visuales:

• Bordes de la carrocería.
• Ruedas.
• Ventanas.
• Faros.
• Texturas.
• Formas generales.

Una CNN puede aprender detectores de características simples en sus primeras capas y combinar esas representaciones en capas posteriores.

Con suficientes datos y una arquitectura adecuada, puede aprender a distinguir entre diferentes categorías de objetos.

Las CNN desempeñaron un papel central en el avance de la visión artificial.

Uno de los trabajos históricos más relevantes fue Gradient-Based Learning Applied to Document Recognition, publicado en 1998 por Yann LeCun, Léon Bottou, Yoshua Bengio y Patrick Haffner.

Este trabajo describió sistemas basados en redes convolucionales para reconocimiento de caracteres y documentos.

Posteriormente, arquitecturas como AlexNet, VGG y ResNet demostraron la capacidad de las CNN para abordar problemas cada vez más complejos de clasificación visual.

En la actualidad, las CNN siguen utilizándose en aplicaciones comerciales, científicas e industriales.

Entre ellas encontramos:

• Reconocimiento de objetos.
• Análisis de imágenes médicas.
• Inspección visual industrial.
• Detección de defectos.
• Clasificación de productos.
• Reconocimiento de logotipos.
• Procesamiento de vídeo.
• Extracción de características visuales.

En aplicaciones de Visibilidad en Inteligencia Artificial (AI Visibility), una CNN puede utilizarse para analizar imágenes de productos, elementos de identidad visual y otros activos de marca.

Sin embargo, una CNN tradicional no mide directamente la frecuencia con la que los asistentes de inteligencia artificial recomiendan una empresa.

Para ese tipo de evaluación se necesitan procedimientos adicionales de análisis de respuestas, procesamiento del lenguaje y medición de indicadores.

En este artículo estudiaremos qué son las CNN, cómo funcionan las convoluciones, qué representan los kernels y filtros, cómo influyen Padding y Stride, cuáles son las diferencias entre Max Pooling y Average Pooling y cómo construir redes convolucionales con NumPy, PyTorch y Keras.

¿Qué es una Red Neuronal Convolucional?

Una Red Neuronal Convolucional es una arquitectura neuronal que utiliza operaciones de convolución o correlación cruzada para aprender características locales mediante filtros compartidos.

Definición breve: Una CNN (Convolutional Neural Network) es una red neuronal profunda que aprende representaciones jerárquicas de datos espaciales o temporales mediante filtros convolucionales, funciones de activación y operaciones de agregación, utilizadas posteriormente para tareas como clasificación, detección o segmentación.

Una CNN es una arquitectura, no un algoritmo de optimización.

Sus parámetros pueden entrenarse utilizando SGD, Momentum, Adam, AdamW y otros optimizadores.

¿Qué significa CNN?

Convolutional Neural Network

En español:

Red Neuronal Convolucional.

Entre los términos relacionados encontramos:

• Convolutional Layer.
• Kernel.
• Filter.
• Feature Map.
• Stride.
• Padding.
• Dilation.
• Receptive Field.
• Max Pooling.
• Average Pooling.
• Global Average Pooling.
• Depthwise Convolution.
• Pointwise Convolution.
• Image Classification.
• Feature Extraction.

¿Por qué se desarrollaron las CNN?

Las imágenes contienen una estructura espacial.

Los píxeles vecinos suelen estar relacionados.

Por ejemplo, un borde visible puede estar formado por una transición entre regiones de diferente intensidad.

Una arquitectura completamente conectada puede procesar una imagen aplanada como un vector, pero no incorpora directamente la misma estructura de procesamiento local y de parámetros compartidos.

Ejemplo: imagen de 224 × 224 píxeles

Una imagen RGB contiene:

224 × 224 × 3 = 150.528 valores

Supongamos una capa completamente conectada con 1.000 neuronas.

El número de pesos sería:

150.528 × 1.000 = 150.528.000

Sin contar los sesgos.

Es una cantidad considerable.

Ahora consideremos una capa convolucional con:

• Tres canales de entrada.
• 64 filtros.
• Kernel de 3 × 3.

El número de pesos sería:

3 × 3 × 3 × 64 = 1.728

Más 64 sesgos, si están habilitados.

¿Qué significa?

La capa convolucional reutiliza sus filtros en diferentes posiciones espaciales.

Esto reduce considerablemente el número de parámetros respecto a una capa densa de la comparación.

Precaución

Menos parámetros no significa necesariamente menos operaciones computacionales.

Un filtro convolucional se aplica en muchas posiciones, y el coste de cálculo puede seguir siendo elevado.

¿Cómo funciona una CNN?

Una CNN clásica realiza varias etapas.

1. Recibir una imagen

Por ejemplo:

32 × 32 × 3

2. Aplicar convoluciones

Los filtros generan mapas de características.

3. Aplicar funciones de activación

Las transformaciones no lineales permiten aprender patrones complejos.

4. Reducir la resolución cuando corresponde

Puede utilizarse Pooling o convoluciones con Stride.

5. Repetir las etapas

Las representaciones se transforman progresivamente.

6. Agregar características

Por ejemplo, mediante Global Average Pooling.

7. Generar predicciones

Una cabeza de clasificación produce logits o valores de salida.

Arquitectura conceptual

Imagen → Convolución → ReLU → Pooling → Convolución → ReLU → Pooling → Clasificador

Esta estructura representa una CNN sencilla.

Las arquitecturas modernas pueden incorporar conexiones residuales, Batch Normalization, mecanismos de atención y otros componentes.

¿Qué es una Convolución?

Una convolución es una operación matemática que combina una entrada con un kernel.

En procesamiento de imágenes, los frameworks de Deep Learning suelen implementar una operación de correlación cruzada, que es muy parecida a la convolución matemática clásica.

Diferencia importante

En una convolución matemática estricta, el kernel se invierte espacialmente.

En la correlación cruzada, se aplica sin esa inversión.

En bibliotecas como PyTorch, Conv2d utiliza correlación cruzada aunque se denomine convolución.

Como los filtros se aprenden durante entrenamiento, esta convención no impide aprender características útiles.

Fórmula de una convolución 2D

Para una entrada X y un kernel K, una correlación cruzada bidimensional sencilla puede expresarse como:

Y(i,j) = Σₘ Σₙ X(i+m,j+n)K(m,n)

Donde:

• X es la matriz de entrada.
• K es el kernel.
• Y es el mapa resultante.
• i y j indican la posición de salida.
• m y n recorren las posiciones del kernel.

¿Qué ocurre en imágenes RGB?

Una imagen tiene varios canales.

Por tanto, cada filtro incluye pesos correspondientes a todos los canales de entrada conectados.

Una formulación con múltiples canales es:

Yₒ(i,j) = bₒ + Σc Σₘ Σₙ Xc(i+m,j+n)Kₒ,c(m,n)

Donde o identifica el filtro de salida y c representa un canal de entrada.

Esta expresión omite Padding, Stride y Dilation para facilitar su lectura.

¿Qué es un Kernel?

Un Kernel es una matriz o tensor pequeño que contiene los pesos utilizados por una operación convolucional.

Ejemplo

Un kernel espacial de 3 × 3 puede representarse como:

 1   0  -1
 1   0  -1
 1   0  -1

Este ejemplo corresponde a un filtro manual relacionado con la detección de bordes verticales.

¿Todos los kernels se diseñan manualmente?

No.

En una CNN convencional, los valores se aprenden durante entrenamiento mediante Backpropagation.

¿Qué tamaños son habituales?

• 1 × 1.
• 3 × 3.
• 5 × 5.
• 7 × 7.

También pueden utilizarse kernels rectangulares.

¿Cuál es el mejor?

Depende de la arquitectura y de los patrones que queremos capturar.

¿Qué diferencia existe entre Kernel y Filter?

En conversaciones técnicas, ambos términos suelen utilizarse de manera intercambiable.

Sin embargo, conviene distinguir sus dimensiones.

Un filtro convolucional completo puede incluir pesos para todos los canales de entrada conectados.

Ejemplo

La entrada tiene tres canales.

Queremos generar un canal de salida utilizando un kernel espacial de 3 × 3.

El filtro contiene:

3 × 3 × 3 = 27 pesos

Si utilizamos 32 filtros de salida, la capa produce 32 mapas de características.

Precaución

Las dimensiones exactas dependen de operaciones agrupadas o Depthwise, donde no todos los canales se conectan de la misma forma.

¿Qué es un Feature Map?

Un Feature Map, o mapa de características, es una representación producida por un filtro o conjunto de operaciones.

Ejemplo

Una imagen tiene tamaño:

64 × 64 × 3

Aplicamos 16 filtros con Padding que conserva las dimensiones espaciales.

El resultado puede ser:

64 × 64 × 16

¿Qué significa?

Cada canal de salida contiene una representación aprendida.

Algunos canales pueden responder a determinadas estructuras visuales.

¿Los filtros detectan siempre conceptos fácilmente interpretables?

No.

Aunque determinados filtros pueden visualizarse como detectores de bordes o texturas, numerosas representaciones internas son distribuidas y no poseen una interpretación semántica única.

Ejemplo matemático de una convolución

Consideremos una imagen en escala de grises de 3 × 3:

1  2  3
4  5  6
7  8  9

Y un kernel de 2 × 2:

1  0
0 -1

Aplicamos correlación cruzada sin Padding y con Stride 1.

Primera posición

Tomamos:

1  2
4  5

Multiplicamos elemento a elemento y sumamos:

1×1 + 2×0 + 4×0 + 5×(−1) = −4

Segunda posición

Utilizamos:

2  3
5  6

Resultado:

2 − 6 = −4

Al repetir la operación obtenemos:

-4  -4
-4  -4

¿Qué demuestra?

Un kernel transforma patrones locales en valores de salida.

¿Qué ocurre durante el entrenamiento?

El modelo aprende los valores de sus kernels según la función de pérdida y los datos.

Ejemplo 1 — Convolución desde cero con NumPy

Implementaremos una correlación cruzada 2D sin Padding.

import numpy as np
image = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
], dtype=float)
kernel = np.array([
    [1, 0],
    [0, -1]
], dtype=float)
def correlate2d(image, kernel):
    height, width = image.shape
    kh, kw = kernel.shape
    out_h = height - kh + 1
    out_w = width - kw + 1
    if out_h <= 0 or out_w <= 0:
        raise ValueError(
            "Kernel mayor que la imagen."
        )
    output = np.zeros(
        (out_h, out_w),
        dtype=float
    )
    for i in range(out_h):
        for j in range(out_w):
            region = image[
                i:i + kh,
                j:j + kw
            ]
            output[i, j] = np.sum(
                region * kernel
            )
    return output
result = correlate2d(
    image,
    kernel
)
print(result)

Resultado esperado

[[-4. -4.]
 [-4. -4.]]

Limitación

La implementación muestra correlación cruzada con un canal, Stride 1 y sin Padding.

Una capa convolucional moderna también debe manejar múltiples canales, lotes, sesgos, Dilation y otras opciones.

¿Qué es Stride?

Stride es el desplazamiento del kernel entre posiciones consecutivas.

Stride = 1

El kernel avanza una posición.

Stride = 2

El kernel avanza dos posiciones.

¿Qué efecto produce?

Un Stride mayor normalmente reduce el número de posiciones de salida.

Ejemplo

Una imagen de 7 × 7 se procesa con un kernel de 3 × 3, sin Padding.

Con Stride 1:

Salida = 5 × 5

Con Stride 2:

Salida = 3 × 3

¿Qué ventaja puede ofrecer?

Reduce resolución y coste de ciertas etapas.

¿Qué desventaja puede tener?

Puede perder información espacial al muestrear menos posiciones.

¿Qué es Padding?

Padding consiste en añadir valores alrededor de los bordes de una entrada antes de realizar una operación.

Una opción habitual es Zero Padding.

Ejemplo

Una entrada de 3 × 3:

1 2 3
4 5 6
7 8 9

Con Padding 1:

0 0 0 0 0
0 1 2 3 0
0 4 5 6 0
0 7 8 9 0
0 0 0 0 0

¿Para qué sirve?

Permite controlar las dimensiones de salida y cómo se procesan las regiones cercanas a los bordes.

¿Qué diferencia existe entre Valid Padding y Same Padding?

Valid Padding

No añade Padding implícito.

El resultado suele ser espacialmente menor que la entrada cuando el kernel es mayor que uno.

Same Padding

Intenta conservar una relación específica entre dimensiones de entrada y salida.

Con Stride 1, normalmente mantiene la misma altura y anchura.

Ejemplo

Entrada:

32 × 32

Kernel:

3 × 3

Stride:

1

Con Valid:

30 × 30

Con Same:

32 × 32

Precaución

Las convenciones exactas de Same Padding con Stride mayor que uno dependen de la biblioteca.

No debemos asumir que PyTorch y Keras admiten todas las combinaciones del mismo modo.

Fórmula de dimensiones de salida

Para una convolución bidimensional, la altura de salida se calcula mediante:

Hout = ⌊(Hin + 2P − D(K − 1) − 1)/S + 1⌋

Donde:

• Hin es la altura de entrada.
• P es Padding simétrico.
• D es Dilation.
• K es el tamaño del kernel.
• S es Stride.

Se aplica una fórmula equivalente para la anchura.

Ejemplo

Hin = 32

P = 1

D = 1

K = 3

S = 2

Entonces:

Hout = ⌊(32 + 2 − 2 − 1)/2 + 1⌋

Hout = 16

Resultado

Una convolución con estas características produce 16 posiciones de salida por dimensión espacial.

¿Qué es Dilation?

Dilation controla la separación entre los elementos del kernel cuando se aplica sobre la entrada.

Ejemplo

Un kernel de 3 × 3 con Dilation 1 observa posiciones contiguas.

Con Dilation 2, sus posiciones efectivas quedan separadas por una celda.

¿Qué aporta?

Permite aumentar el campo espacial cubierto por el kernel sin incrementar necesariamente el número de pesos.

Tamaño efectivo

Kefectivo = D(K − 1) + 1

Para:

K = 3

D = 2

Obtenemos:

Kefectivo = 5

¿Significa que contiene 25 pesos?

No.

El kernel sigue teniendo nueve posiciones espaciales de pesos por conexión de canal, aunque cubre un área mayor.

¿Qué es Pooling?

Pooling es una operación que agrega información de regiones locales de un mapa de características.

Se utiliza para reducir resolución o resumir información.

Entre las modalidades más conocidas encontramos:

• Max Pooling.
• Average Pooling.
• Global Average Pooling.

No todas las CNN modernas necesitan capas de Pooling explícitas.

Algunas realizan la reducción espacial mediante convoluciones con Stride.

¿Qué es Max Pooling?

Max Pooling selecciona el valor máximo dentro de una ventana.

Ejemplo

Entrada:

1  5
3  2

Max Pooling 2 × 2 devuelve:

5

¿Por qué puede ser útil?

Conserva la respuesta más alta dentro de la región.

Precaución

Una respuesta máxima no siempre representa la característica más informativa para todas las tareas.

El efecto depende de la representación aprendida.

¿Qué es Average Pooling?

Average Pooling calcula la media de los valores dentro de una región.

Ejemplo

Entrada:

1  5
3  2

Resultado:

(1 + 5 + 3 + 2)/4 = 2,75

Diferencia frente a Max Pooling

Max Pooling conserva el máximo.

Average Pooling resume la magnitud media.

¿Cuál es superior?

No existe una respuesta universal.

Depende de la tarea y del diseño de la red.

Ejemplo 2 — Max Pooling con NumPy

import numpy as np
image = np.array([
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 1, 2, 3],
    [4, 5, 6, 7]
])
def max_pool2d(x, pool_size=2):
    h, w = x.shape
    if h % pool_size or w % pool_size:
        raise ValueError(
            "Dimensiones no divisibles por pool_size."
        )
    result = np.zeros(
        (
            h // pool_size,
            w // pool_size
        ),
        dtype=x.dtype
    )
    for i in range(0, h, pool_size):
        for j in range(0, w, pool_size):
            region = x[
                i:i + pool_size,
                j:j + pool_size
            ]
            result[
                i // pool_size,
                j // pool_size
            ] = region.max()
    return result
print(max_pool2d(image))

Resultado

[[6 8]
 [9 7]]

¿Qué demuestra?

Cada región de 2 × 2 se sustituye por su valor máximo.

¿Qué es Global Average Pooling?

Global Average Pooling (GAP) calcula un promedio espacial por canal.

Ejemplo

Tenemos un tensor de características:

[Batch, 128, 8, 8]

En formato PyTorch.

Después de Global Average Pooling:

[Batch, 128, 1, 1]

Al eliminar las dimensiones espaciales:

[Batch, 128]

¿Por qué importa?

Permite convertir mapas de características en vectores compactos.

También puede reducir la necesidad de capas densas muy grandes.

¿Dónde se utiliza?

En numerosas CNN modernas, incluidas determinadas arquitecturas ResNet.

¿Qué es Receptive Field?

El Campo Receptivo (Receptive Field) es la región de la entrada que puede influir en una unidad de una capa posterior.

Ejemplo

Una convolución de 3 × 3 sobre una imagen observa una región local de 3 × 3.

Pero si aplicamos varias convoluciones consecutivas, las unidades posteriores pueden depender de regiones más grandes.

Dos convoluciones de 3 × 3

Con Stride 1 y sin Dilation:

Campo receptivo teórico = 5 × 5

Tres convoluciones

Campo receptivo teórico = 7 × 7

¿Qué significa?

Las capas profundas pueden combinar información de regiones progresivamente mayores.

Precaución

El campo receptivo teórico no describe necesariamente la influencia efectiva de cada píxel.

En una red entrenada, las contribuciones reales pueden concentrarse en una región menor.

Fórmula del campo receptivo

Una formulación recursiva útil es:

rₗ = rₗ₋₁ + (Kₗ − 1)Dₗjₗ₋₁

jₗ = jₗ₋₁Sₗ

Donde:

• r es el tamaño del campo receptivo.
• j es el salto efectivo entre unidades de salida respecto a la entrada.
• K es el tamaño de kernel.
• D es Dilation.
• S es Stride.

Condiciones iniciales:

r₀ = 1

j₀ = 1

Ejemplo

Dos convoluciones de 3 × 3 con Stride 1 y Dilation 1:

Primera capa:

r₁ = 1 + 2 = 3

Segunda capa:

r₂ = 3 + 2 = 5

Resultado

5 × 5

Esta fórmula representa el recorrido espacial teórico y presupone una secuencia compatible de operaciones.

¿Qué es Parameter Sharing?

Parameter Sharing significa compartir parámetros.

En una CNN, los mismos pesos de un filtro se utilizan en diferentes posiciones espaciales.

¿Por qué importa?

Reduce la cantidad de parámetros y permite buscar patrones similares en distintas posiciones.

Ejemplo

Un filtro que responde a determinados bordes puede aplicarse a la parte superior, inferior o central de una imagen.

¿Garantiza invariancia a la posición?

No completamente.

La convolución estándar presenta una propiedad de equivariancia a traslaciones bajo condiciones ideales.

La invariancia requiere mecanismos adicionales, agregación o aprendizaje apropiado.

Equivarianza frente a Invariancia

Estos conceptos suelen confundirse.

Equivarianza

Una transformación de la entrada produce una transformación correspondiente en la salida.

Por ejemplo, si desplazamos un patrón visual, su respuesta en un mapa de características puede desplazarse de forma similar.

Invariancia

La salida permanece aproximadamente igual ante una transformación de la entrada.

Por ejemplo, un clasificador podría seguir reconociendo un objeto pese a un desplazamiento moderado.

¿Las CNN son completamente invariantes a traslaciones?

No.

Padding, Stride, bordes, Pooling y otras operaciones pueden modificar esta propiedad.

¿Qué es una Convolución 1 × 1?

Una convolución de 1 × 1 combina canales en cada posición espacial.

¿Es una operación útil aunque no observe vecinos?

Sí.

Puede transformar la dimensión de canales y aprender combinaciones de características.

Ejemplo

Entrada:

[Batch, 64, 32, 32]

Aplicamos:

nn.Conv2d(
    in_channels=64,
    out_channels=128,
    kernel_size=1
)

Salida:

[Batch, 128, 32, 32]

Aplicaciones

• Ajuste de canales.
• Bloques Bottleneck.
• Projection Shortcuts.
• Arquitecturas eficientes.

¿Qué es Depthwise Convolution?

Una Depthwise Convolution aplica filtros espacialmente a canales de entrada por separado, según el multiplicador de profundidad configurado.

En lugar de combinar todos los canales de entrada en cada filtro, utiliza grupos separados.

¿Por qué importa?

Puede reducir considerablemente el número de parámetros y operaciones en determinadas arquitecturas.

¿Qué es Depthwise Separable Convolution?

Es una combinación frecuente de:

1. Depthwise Convolution.
2. Pointwise Convolution de 1 × 1.

La primera procesa información espacial por canal.

La segunda combina información entre canales.

¿Dónde aparece?

En familias como MobileNet.

Precaución

Menos operaciones teóricas no garantiza siempre menor latencia real en cualquier hardware.

¿Cuántos parámetros tiene una capa convolucional?

Para una convolución estándar sin grupos:

Parámetros = Kh × Kw × Cin × Cout + Cout

Si hay sesgos.

Ejemplo

Kernel:

3 × 3

Canales de entrada:

32

Canales de salida:

64

Entonces:

3 × 3 × 32 × 64 + 64 = 18.496 parámetros

¿Qué ocurre sin sesgo?

Serían:

18.432 parámetros

¿Qué cambia con Groups?

Cada filtro se conecta solamente con una fracción de los canales.

Para grupos uniformes:

Pesos = Kh × Kw × (Cin / Groups) × Cout

Más los sesgos opcionales.

Ejemplo 3 — Crear una CNN con PyTorch

PyTorch proporciona la clase:

torch.nn.Conv2d

Vamos a construir una CNN pequeña para imágenes RGB.

import torch
import torch.nn as nn
class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(
                3, 32,
                kernel_size=3,
                padding=1
            ),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(
                32, 64,
                kernel_size=3,
                padding=1
            ),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(
                64, 128,
                kernel_size=3,
                padding=1
            ),
            nn.ReLU()
        )
        self.pool = nn.AdaptiveAvgPool2d(
            (1, 1)
        )
        self.classifier = nn.Linear(
            128,
            num_classes
        )
    def forward(self, x):
        x = self.features(x)
        x = self.pool(x)
        x = torch.flatten(x, 1)
        return self.classifier(x)
model = SimpleCNN()
X = torch.randn(
    8, 3, 32, 32
)
logits = model(X)
print("Salida:", logits.shape)

Resultado esperado

[8, 10]

¿Qué demuestra?

La red utiliza:

• Tres capas convolucionales.
• ReLU.
• Dos capas de Max Pooling.
• Global Average Pooling.
• Una capa final de clasificación.

¿Por qué no aplicar Softmax en forward?

Porque nn.CrossEntropyLoss espera logits y realiza internamente las operaciones numéricas necesarias.

¿Cuál es la diferencia entre NCHW y NHWC?

Los frameworks pueden utilizar diferentes órdenes de dimensiones.

PyTorch

La convención habitual para Conv2d es:

[N, C, H, W]

Donde:

• N es Batch Size.
• C son canales.
• H es altura.
• W es anchura.

Keras

Con channels_last, la forma habitual es:

[N, H, W, C]

Ejemplo

Ocho imágenes RGB de 32 × 32 píxeles.

PyTorch:

[8, 3, 32, 32]

Keras:

[8, 32, 32, 3]

¿Por qué importa?

Una transposición incorrecta puede producir errores o interpretaciones equivocadas de los canales.

Ejemplo 4 — Verificar dimensiones en PyTorch

import torch
import torch.nn as nn
x = torch.randn(8, 3, 32, 32)
conv1 = nn.Conv2d(
    3, 16,
    kernel_size=3,
    stride=1,
    padding=1
)
pool = nn.MaxPool2d(
    kernel_size=2,
    stride=2
)
conv2 = nn.Conv2d(
    16, 32,
    kernel_size=3,
    stride=2,
    padding=1
)
x = conv1(x)
print("Conv1:", x.shape)
x = pool(x)
print("Pooling:", x.shape)
x = conv2(x)
print("Conv2:", x.shape)

Resultado esperado

Conv1:   [8, 16, 32, 32]
Pooling: [8, 16, 16, 16]
Conv2:   [8, 32, 8, 8]

¿Qué demuestra?

El número de canales y las dimensiones espaciales cambian según los parámetros de cada operación.

Ejemplo 5 — Entrenamiento completo de una CNN con PyTorch

Vamos a entrenar un clasificador de imágenes sobre CIFAR-10.

Este dataset contiene diez categorías de objetos y animales en imágenes de 32 × 32 píxeles.

El procedimiento incluirá:

• Descarga de datos.
• División de entrenamiento y validación.
• CNN.
• AdamW.
• Early Stopping.
• Evaluación final sobre Test Set.
• Guardado del modelo.

Instalación

pip install torch torchvision numpy scikit-learn

Código completo

import copy
import math
import torch
import torch.nn as nn
from torch.utils.data import (
    DataLoader,
    Subset
)
from torchvision import (
    datasets,
    transforms
)
from sklearn.model_selection import (
    train_test_split
)
from sklearn.metrics import (
    classification_report
)
torch.manual_seed(42)
device = torch.device(
    "cuda" if torch.cuda.is_available()
    else "cpu"
)
# 1. Transformaciones
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(
        mean=(0.5, 0.5, 0.5),
        std=(0.5, 0.5, 0.5)
    )
])
# 2. Dataset original de entrenamiento
train_full = datasets.CIFAR10(
    root="./data",
    train=True,
    download=True,
    transform=transform
)
# 3. Test Set oficial independiente
test_dataset = datasets.CIFAR10(
    root="./data",
    train=False,
    download=True,
    transform=transform
)
indices = list(range(len(train_full)))
train_indices, val_indices = train_test_split(
    indices,
    test_size=0.20,
    random_state=42,
    stratify=train_full.targets
)
train_dataset = Subset(
    train_full,
    train_indices
)
val_dataset = Subset(
    train_full,
    val_indices
)
generator = torch.Generator()
generator.manual_seed(42)
train_loader = DataLoader(
    train_dataset,
    batch_size=128,
    shuffle=True,
    generator=generator,
    num_workers=0
)
val_loader = DataLoader(
    val_dataset,
    batch_size=256,
    shuffle=False,
    num_workers=0
)
test_loader = DataLoader(
    test_dataset,
    batch_size=256,
    shuffle=False,
    num_workers=0
)
# 4. Modelo CNN
class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, 3, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(64, 128, 3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU()
        )
        self.pool = nn.AdaptiveAvgPool2d(
            (1, 1)
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Dropout(0.2),
            nn.Linear(128, 10)
        )
    def forward(self, x):
        x = self.features(x)
        x = self.pool(x)
        return self.classifier(x)
model = CNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=0.001,
    weight_decay=0.001
)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
    optimizer,
    T_max=15,
    eta_min=1e-5
)
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
            )
            n = labels.size(0)
            total_loss += loss.item() * n
            predictions = logits.argmax(
                dim=1
            )
            total_correct += (
                predictions == labels
            ).sum().item()
            total_examples += n
    return (
        total_loss / total_examples,
        total_correct / total_examples
    )
# 5. Entrenamiento
best_val_loss = float("inf")
best_state = None
best_epoch = None
patience = 5
wait = 0
for epoch in range(1, 16):
    model.train()
    running_loss = 0.0
    count = 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()
        optimizer.step()
        n = labels.size(0)
        running_loss += loss.item() * n
        count += n
    train_loss = running_loss / count
    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()
# 6. Restaurar mejor modelo
if best_state is None:
    raise RuntimeError(
        "No se obtuvo un modelo válido."
    )
model.load_state_dict(best_state)
# 7. Evaluación independiente
test_loss, test_accuracy = evaluate(
    test_loader
)
print("Mejor época:", best_epoch)
print("Test Loss:", test_loss)
print("Test Accuracy:", test_accuracy)
# 8. Métricas por clase
y_true = []
y_pred = []
model.eval()
with torch.inference_mode():
    for images, labels in test_loader:
        images = images.to(device)
        predictions = model(images).argmax(
            dim=1
        ).cpu().tolist()
        y_true.extend(labels.tolist())
        y_pred.extend(predictions)
print(
    classification_report(
        y_true,
        y_pred,
        target_names=test_dataset.classes,
        zero_division=0
    )
)
# 9. Guardar pesos
torch.save(
    model.state_dict(),
    "cnn_cifar10.pt"
)

¿Qué demuestra este experimento?

El código entrena una CNN desde cero sobre imágenes reales de CIFAR-10.

Incluye una división de validación derivada del conjunto oficial de entrenamiento.

El conjunto de prueba oficial permanece reservado para la evaluación final.

¿Qué resultados podemos esperar?

La precisión dependerá de la ejecución, los recursos, la inicialización y el número de épocas.

No debe asumirse una precisión concreta sin ejecutar el entrenamiento.

Limitaciones

El ejemplo utiliza una CNN relativamente sencilla.

No representa necesariamente el rendimiento de arquitecturas más avanzadas como ResNet o EfficientNet.

Para una comparación científica rigurosa conviene evaluar varias semillas y controlar los presupuestos de entrenamiento.

Ejemplo 6 — Crear una CNN con Keras

Keras ofrece capas convolucionales mediante:

keras.layers.Conv2D

El ejemplo siguiente utiliza imágenes RGB de 32 × 32 píxeles.

import keras
from keras import layers
model = keras.Sequential([
    layers.Input(
        shape=(32, 32, 3)
    ),
    layers.Conv2D(
        32,
        kernel_size=3,
        padding="same",
        activation="relu"
    ),
    layers.MaxPooling2D(
        pool_size=2
    ),
    layers.Conv2D(
        64,
        kernel_size=3,
        padding="same",
        activation="relu"
    ),
    layers.MaxPooling2D(
        pool_size=2
    ),
    layers.Conv2D(
        128,
        kernel_size=3,
        padding="same",
        activation="relu"
    ),
    layers.GlobalAveragePooling2D(),
    layers.Dropout(0.2),
    layers.Dense(10)
])
model.compile(
    optimizer=keras.optimizers.AdamW(
        learning_rate=0.001
    ),
    loss=keras.losses.SparseCategoricalCrossentropy(
        from_logits=True
    ),
    metrics=["accuracy"]
)
model.summary()

¿Qué demuestra?

La red utiliza:

• Conv2D.
• MaxPooling2D.
• GlobalAveragePooling2D.
• Dropout.
• Dense.
• AdamW.

¿Qué forma tienen los datos?

Con la configuración channels_last, Keras espera:

[Batch, Height, Width, Channels]

Ejemplo 7 — Entrenar una CNN con Keras y CIFAR-10

Vamos a incorporar una separación explícita entre entrenamiento y validación.

import numpy as np
import keras
from sklearn.model_selection import (
    train_test_split
)
(x_dev, y_dev), (x_test, y_test) = (
    keras.datasets.cifar10.load_data()
)
# Imágenes de uint8 a float32 [0, 1]
x_dev = x_dev.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0
y_dev = y_dev.ravel()
y_test = y_test.ravel()
x_train, x_val, y_train, y_val = train_test_split(
    x_dev,
    y_dev,
    test_size=0.2,
    random_state=42,
    stratify=y_dev
)
callbacks = [
    keras.callbacks.EarlyStopping(
        monitor="val_loss",
        patience=5,
        restore_best_weights=True
    ),
    keras.callbacks.ReduceLROnPlateau(
        monitor="val_loss",
        factor=0.5,
        patience=2,
        min_lr=1e-6
    )
]
history = model.fit(
    x_train,
    y_train,
    validation_data=(
        x_val,
        y_val
    ),
    epochs=30,
    batch_size=128,
    callbacks=callbacks
)
test_loss, test_accuracy = model.evaluate(
    x_test,
    y_test,
    verbose=0
)
print("Test Loss:", test_loss)
print("Test Accuracy:", test_accuracy)

¿Qué demuestra?

El ejemplo entrena el modelo Keras definido anteriormente y utiliza Early Stopping y ReduceLROnPlateau.

Precaución

El código presupone que model ya corresponde a la arquitectura del ejemplo anterior.

Los datos de prueba no se utilizan para seleccionar hiperparámetros.

¿Qué relación existe entre CNN y Backpropagation?

Las CNN se entrenan mediante gradientes como otras redes neuronales diferenciables.

Durante Forward Propagation se calculan los mapas de características y las predicciones.

Después se calcula la función de pérdida.

Backpropagation obtiene derivadas respecto a:

• Pesos de los filtros.
• Sesgos.
• Parámetros de normalización.
• Parámetros de clasificación.

El optimizador utiliza esos gradientes para actualizar el modelo.

¿Los kernels se aprenden automáticamente?

Sí, en el entrenamiento supervisado convencional.

El modelo modifica los valores de sus filtros según los ejemplos y la función objetivo.

¿Qué funciones de pérdida utilizan las CNN?

Depende de la tarea.

Clasificación multiclase

Una opción habitual es Cross-Entropy.

Clasificación binaria

Puede utilizarse Binary Cross-Entropy.

Clasificación multietiqueta

Puede utilizarse Binary Cross-Entropy por etiqueta.

Regresión

Pueden utilizarse MSE, MAE u otras pérdidas apropiadas.

Segmentación

Se utilizan diferentes pérdidas por píxel o región, incluidas variantes de Cross-Entropy y Dice Loss.

¿Existe una única pérdida para todas las CNN?

No.

La función debe corresponder con el objetivo y el formato de las etiquetas.

¿Qué es Data Augmentation en CNN?

Data Augmentation consiste en generar variaciones controladas de los ejemplos de entrenamiento.

Técnicas frecuentes

• Recortes aleatorios.
• Volteos horizontales.
• Rotaciones moderadas.
• Cambios de iluminación.
• Cambios de contraste.
• Transformaciones de escala.

¿Por qué puede ayudar?

Permite que el modelo observe variaciones de imágenes que conservan las propiedades relevantes para la tarea.

Precaución

No todas las transformaciones conservan la etiqueta.

Por ejemplo, un volteo de texto puede alterar su legibilidad.

En sistemas de reconocimiento de logotipos, un recorte puede eliminar el elemento que se pretende identificar.

CNN y Batch Normalization

Batch Normalization es un componente habitual en determinadas CNN.

¿Para qué sirve?

Normaliza activaciones usando estadísticas calculadas durante entrenamiento, bajo una convención específica de dimensiones.

¿Qué puede aportar?

Puede facilitar determinadas condiciones de optimización y modificar la estabilidad del entrenamiento.

¿Es obligatorio utilizarlo?

No.

Existen arquitecturas que utilizan otros procedimientos o prescinden de normalización explícita.

CNN y Dropout

Dropout desactiva estocásticamente determinadas activaciones durante entrenamiento.

¿Por qué se utiliza?

Como técnica de regularización.

¿Dónde puede aplicarse?

En diferentes etapas, incluida la cabeza de clasificación.

¿Debe utilizarse siempre?

No.

En arquitecturas convolucionales modernas pueden emplearse diferentes estrategias de regularización.

La selección debe basarse en validación.

CNN y ResNet

ResNet es una familia de CNN que utiliza conexiones residuales.

CNN convencional

Puede construirse como una secuencia de convoluciones, activaciones y Pooling.

ResNet

Organiza numerosas convoluciones en bloques con shortcuts.

¿Qué aporta ResNet?

Puede facilitar la optimización de arquitecturas profundas.

¿Todas las CNN son ResNet?

No.

ResNet es una familia específica dentro de un conjunto mucho más amplio de arquitecturas convolucionales.

CNN frente a Vision Transformer

Las CNN utilizan operaciones convolucionales como mecanismo principal de procesamiento visual.

Los Vision Transformers utilizan mecanismos de atención sobre representaciones de imágenes.

¿Cuál es mejor?

No existe una respuesta universal.

Conviene comparar modelos concretos bajo los mismos requisitos de datos, latencia, memoria y calidad.

CNN frente a Redes Completamente Conectadas

Una red completamente conectada aplica transformaciones densas.

Una CNN utiliza filtros locales compartidos.

Diferencia importante

Una CNN incorpora una estructura de procesamiento apropiada para datos espaciales.

¿Las capas Dense siguen siendo útiles?

Sí.

Muchas CNN utilizan capas densas al final, aunque Global Average Pooling permite reducir su tamaño.

¿Una CNN siempre utiliza menos parámetros?

No necesariamente.

Depende del diseño y de la comparación.

¿Por qué las CNN importan para AI Visibility?

Una plataforma de AI Visibility puede analizar elementos visuales relacionados con marcas.

Entre los casos de uso encontramos:

• Clasificación de imágenes comerciales.
• Identificación de tipos de activos.
• Análisis de imágenes de productos.
• Inspección de capturas de páginas web.
• Detección de determinadas características visuales.

Una CNN puede utilizarse como extractor de representaciones para esos análisis.

Ejemplo empresarial

Una organización quiere comprobar si sus fotografías de productos pertenecen correctamente a las categorías comerciales utilizadas en su catálogo.

Puede entrenar o adaptar una CNN para clasificar esas imágenes.

¿Qué aporta al sistema de AI Visibility?

Puede mejorar la organización y el análisis de los activos visuales.

¿Aumenta directamente las recomendaciones de asistentes de IA?

No.

Una CNN externa no modifica automáticamente las decisiones de recomendación de ChatGPT, Gemini, Claude o Perplexity.

Ejemplo 8 — CNN para clasificar activos visuales de marca

Supongamos tres categorías:

• Logotipo.
• Fotografía de producto.
• Captura de página web.

Podemos construir un clasificador.

import torch
import torch.nn as nn
class BrandVisualCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(
                3, 32,
                kernel_size=3,
                padding=1
            ),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(
                32, 64,
                kernel_size=3,
                padding=1
            ),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(
                64, 128,
                kernel_size=3,
                padding=1
            ),
            nn.ReLU()
        )
        self.pool = nn.AdaptiveAvgPool2d(
            1
        )
        self.classifier = nn.Linear(
            128,
            3
        )
    def forward(self, x):
        x = self.features(x)
        x = self.pool(x).flatten(1)
        return self.classifier(x)
model = BrandVisualCNN()
X = torch.randn(
    16, 3, 128, 128
)
logits = model(X)
print(logits.shape)

Resultado

[16, 3]

¿Qué demuestra?

La arquitectura puede producir puntuaciones para tres tipos de activos visuales.

Limitación

Los datos son aleatorios.

No existe entrenamiento ni validación en este ejemplo.

Para convertirlo en un clasificador comercial se necesita un conjunto de imágenes etiquetadas y un procedimiento de evaluación.

CNN y reconocimiento de logotipos

El reconocimiento de logotipos puede formularse de diferentes maneras.

Clasificación

Determinar a qué marca pertenece una imagen.

Detección

Localizar uno o varios logotipos dentro de una imagen.

Recuperación visual

Buscar imágenes similares mediante embeddings.

¿Una CNN clasificadora localiza automáticamente un logotipo?

No necesariamente.

Una CNN de clasificación puede predecir una categoría sin proporcionar coordenadas fiables de localización.

Para localizar objetos se necesitan arquitecturas o métodos adecuados a esa tarea.

CNN y OCR

El reconocimiento óptico de caracteres convierte imágenes de texto en resultados textuales.

¿Se utilizan CNN en OCR?

Sí, pueden formar parte del extractor visual de sistemas de reconocimiento.

¿Una CNN convencional lee texto por sí sola?

No.

Un sistema OCR completo puede necesitar componentes para segmentación, reconocimiento de secuencias, decodificación y posprocesamiento.

¿Por qué importa en AI Visibility?

Porque algunas capturas de páginas web incluyen nombres de marcas, características de productos y mensajes comerciales.

El OCR permite acceder a contenido textual representado visualmente.

CNN y análisis de imágenes de productos

Las CNN pueden entrenarse para reconocer características visuales de productos.

Ejemplos

• Categoría comercial.
• Tipo de objeto.
• Presencia de determinados componentes.
• Defectos visuales.
• Variaciones de presentación.

¿Pueden reconocer cualquier producto sin entrenamiento específico?

No.

Los modelos dependen de los datos y del dominio.

Para categorías comerciales especializadas puede ser necesario Transfer Learning.

¿Qué es Transfer Learning en CNN?

Transfer Learning reutiliza las características aprendidas previamente por un modelo.

Ejemplo

Una ResNet preentrenada en ImageNet puede adaptarse a una tarea de clasificación de productos industriales.

Procedimiento

1. Cargar el backbone preentrenado.
2. Sustituir la cabeza final.
3. Entrenar sobre datos propios.
4. Evaluar el resultado.
5. Descongelar capas adicionales cuando corresponda.

¿Qué ventaja puede tener?

Puede reducir la necesidad de entrenar todos los parámetros desde cero.

¿Está garantizado?

No.

Depende de la similitud entre los datos originales y la nueva tarea.

¿Qué recursos necesita una CNN?

El coste depende de:

• Resolución de entrada.
• Número de filtros.
• Tamaño de kernels.
• Profundidad.
• Batch Size.
• Precisión numérica.
• Hardware.
• Tipo de optimizador.

¿Una CNN necesita GPU?

No.

Puede ejecutarse en CPU.

Sin embargo, las operaciones convolucionales suelen beneficiarse de aceleración en modelos grandes.

¿Qué opción utilizar para comenzar?

Una CNN pequeña con CIFAR-10 permite aprender los fundamentos sin comenzar con una arquitectura de cientos de capas.

¿Cómo evaluar una CNN?

Las métricas dependen de la tarea.

Clasificación

• Accuracy.
• Precision.
• Recall.
• Macro-F1.
• Matriz de confusión.

Detección de objetos

• Precision y Recall de detección.
• Average Precision.
• mAP bajo una definición concreta.

Segmentación

• Intersection over Union.
• Dice Score.
• Métricas por clase.

Sistemas comerciales

También conviene medir:

• Latencia.
• Throughput.
• Memoria.
• Tamaño del modelo.
• Coste operativo.
• Robustez ante cambios de dominio.

¿Por qué no basta con Training Accuracy?

Porque puede resultar optimista respecto al rendimiento en imágenes nuevas.

La evaluación debe realizarse sobre datos independientes.

Errores frecuentes al trabajar con CNN

Error 1. Confundir convolución estricta y correlación cruzada

Las bibliotecas suelen utilizar correlación cruzada.

Error 2. Ignorar el orden de los canales

PyTorch y Keras utilizan diferentes convenciones habituales.

Error 3. Calcular incorrectamente la salida de una convolución

Stride, Padding y Dilation afectan a las dimensiones.

Error 4. Confundir número de filtros y tamaño del kernel

Controlan aspectos diferentes.

Error 5. Suponer que todos los filtros detectan bordes interpretables

Las representaciones pueden ser complejas.

Error 6. Confundir equivarianza e invariancia

No son la misma propiedad.

Error 7. Utilizar Pooling sin considerar la información perdida

La reducción espacial puede eliminar detalles.

Error 8. Utilizar un clasificador como detector de objetos

Son tareas distintas.

Error 9. Aplicar Softmax antes de CrossEntropyLoss en PyTorch

No es necesario para la API convencional.

Error 10. No controlar las transformaciones de las imágenes

Un preprocesamiento incorrecto puede perjudicar el modelo.

Error 11. Utilizar aumentos de datos que cambian las etiquetas

Puede introducir ruido.

Error 12. Mezclar imágenes duplicadas entre Train y Test

Puede producir métricas engañosas.

Error 13. Seleccionar arquitectura solamente por Accuracy

También importan latencia, memoria y robustez.

Error 14. Suponer que una CNN más profunda siempre generaliza mejor

No existe esa garantía.

Error 15. Confundir reconocimiento visual con medición directa de recomendaciones de IA

Son tareas diferentes.

Buenas prácticas para entrenar CNN

1. Definir claramente la tarea.
2. Verificar las etiquetas.
3. Separar Train, Validation y Test.
4. Evitar duplicados entre particiones.
5. Comprobar el orden de dimensiones.
6. Utilizar preprocesamiento apropiado.
7. Comenzar con una arquitectura sencilla.
8. Monitorizar pérdida y métricas de validación.
9. Aplicar Data Augmentation cuando conserve la etiqueta.
10. Comparar con modelos preentrenados.
11. Utilizar Early Stopping cuando corresponda.
12. Ajustar Learning Rate mediante validación.
13. Medir errores por clase.
14. Evaluar latencia y memoria.
15. Documentar arquitectura y configuración experimental.

En aplicaciones de AI Visibility también conviene evaluar el comportamiento con nuevas marcas, estilos visuales, tamaños de imagen y fuentes de contenido.

Preguntas frecuentes sobre CNN

¿Qué significa CNN?

Convolutional Neural Network.

¿Qué es una Red Neuronal Convolucional?

Es una arquitectura neuronal que aprende características mediante filtros convolucionales.

¿Para qué sirve una CNN?

Para procesar datos estructurados espacial o temporalmente, especialmente imágenes.

¿Las CNN son parte de Deep Learning?

Sí.

¿Quién desarrolló las CNN?

Surgieron de múltiples contribuciones históricas. Yann LeCun y colaboradores realizaron trabajos especialmente influyentes sobre redes convolucionales para reconocimiento de documentos.

¿Qué es LeNet?

Es una familia histórica de redes convolucionales asociada con el reconocimiento de caracteres.

¿Qué es una Convolutional Layer?

Es una capa que aplica filtros aprendibles sobre regiones de la entrada.

¿Qué es un Kernel?

Es el conjunto de pesos espaciales utilizados en una operación convolucional.

¿Qué es un Filter?

Es un conjunto de pesos que produce un canal de salida, considerando las conexiones entre canales.

¿Qué es un Feature Map?

Es una representación producida por una capa convolucional.

¿Qué es Stride?

Es el desplazamiento del kernel entre posiciones.

¿Qué es Padding?

Es añadir valores alrededor de la entrada para controlar el procesamiento de los bordes y las dimensiones.

¿Qué es Valid Padding?

Es una operación sin Padding implícito.

¿Qué es Same Padding?

Es una convención destinada a conservar determinadas relaciones de dimensiones, habitualmente la misma resolución con Stride 1.

¿Qué es Dilation?

Es la separación entre posiciones del kernel cuando se aplica sobre la entrada.

¿Qué es Max Pooling?

Es una operación que selecciona el máximo dentro de una región.

¿Qué es Average Pooling?

Es una operación que calcula el promedio de una región.

¿Qué es Global Average Pooling?

Es calcular una media espacial por canal.

¿Qué es Receptive Field?

Es la región de la entrada que puede influir en una unidad posterior.

¿Qué es Parameter Sharing?

Es reutilizar los mismos pesos de un filtro en varias posiciones.

¿Qué es Equivariance?

Es que una transformación de entrada produzca una transformación correspondiente en la salida.

¿Qué es Invariance?

Es mantener la salida aproximadamente estable ante ciertas transformaciones.

¿Las CNN son invariantes a traslaciones?

No de manera perfecta o universal.

¿Qué es una convolución 1 × 1?

Es una operación que combina canales en cada posición espacial.

¿Qué es Depthwise Convolution?

Es una convolución que procesa canales separadamente mediante grupos apropiados.

¿Qué es Pointwise Convolution?

Es habitualmente una convolución de 1 × 1.

¿Qué es Depthwise Separable Convolution?

Es la combinación de operaciones Depthwise y Pointwise.

¿Qué es NCHW?

Es el orden Batch, Channels, Height, Width.

¿Qué es NHWC?

Es el orden Batch, Height, Width, Channels.

¿Qué formato utiliza PyTorch?

Habitualmente NCHW para Conv2d.

¿Qué formato utiliza Keras?

Habitualmente NHWC con channels_last.

¿Qué es Conv2D en Keras?

Es una capa de convolución bidimensional.

¿Qué es nn.Conv2d en PyTorch?

Es una capa convolucional bidimensional entrenable.

¿Qué es Backpropagation en CNN?

Es el procedimiento utilizado para calcular gradientes de los filtros y otros parámetros.

¿Las CNN aprenden filtros automáticamente?

Sí, durante el entrenamiento convencional.

¿Qué optimizador utiliza una CNN?

Puede utilizar SGD, Adam, AdamW y otros.

¿Qué función de pérdida utiliza?

Depende de la tarea.

¿Qué es Data Augmentation?

Es generar variaciones controladas de los ejemplos de entrenamiento.

¿Qué es BatchNorm?

Es una técnica de normalización utilizada en numerosas CNN.

¿Qué es Dropout?

Es una técnica de regularización estocástica.

¿Qué es ResNet?

Es una familia de CNN basada en conexiones residuales.

¿Todas las CNN son ResNet?

No.

¿Qué es AlexNet?

Es una arquitectura convolucional histórica de reconocimiento visual.

¿Qué es VGG?

Es una familia de CNN que utiliza bloques de convoluciones y una estructura relativamente uniforme.

¿Qué es MobileNet?

Es una familia de arquitecturas visuales orientada a diseños eficientes.

¿Qué es EfficientNet?

Es una familia de modelos visuales que estudia estrategias de escalado y eficiencia.

¿Qué es CIFAR-10?

Es un dataset de diez clases de imágenes de 32 × 32 píxeles.

¿Qué es ImageNet?

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

¿Las CNN requieren GPU?

No.

¿Las CNN sirven para OCR?

Pueden formar parte de sistemas OCR.

¿Las CNN sirven para segmentación?

Sí, dentro de arquitecturas apropiadas.

¿Las CNN detectan objetos?

Pueden utilizarse como componentes de detectores.

¿Las CNN reconocen logotipos?

Pueden entrenarse o adaptarse a esa tarea.

¿Qué es Transfer Learning?

Es reutilizar representaciones aprendidas en otra tarea.

¿Qué es Fine-Tuning?

Es adaptar parámetros de un modelo preentrenado.

¿Qué diferencia existe entre CNN y Vision Transformer?

Utilizan mecanismos arquitectónicos principales diferentes, convolución y atención respectivamente.

¿Las CNN pueden procesar audio?

Sí, mediante representaciones y variantes adecuadas.

¿Las CNN procesan vídeo?

Sí, mediante arquitecturas 2D, 3D u otros diseños apropiados.

¿Las CNN garantizan precisión alta?

No.

¿Qué importancia tienen para AI Visibility?

Pueden analizar activos visuales relacionados con marcas y productos.

¿Una CNN aumenta Recommendation Rate?

No directamente.

¿Una CNN modifica las respuestas de ChatGPT?

No cuando se utiliza como modelo independiente de análisis visual.

Conceptos relacionados

• Inteligencia Artificial: sistemas capaces de realizar tareas inteligentes.
• Aprendizaje Automático: modelos que aprenden a partir de datos.
• Aprendizaje Profundo: entrenamiento de redes con múltiples capas.
• Redes Neuronales: modelos formados por transformaciones entrenables.
• Visión por Computadora: procesamiento automatizado de imágenes.
• Aprendizaje Supervisado: entrenamiento con ejemplos etiquetados.
• Clasificación: predicción de categorías.
• Regresión: predicción numérica.
• Extracción de Características: construcción de representaciones útiles.
• Aumento de Datos: generación de variaciones de entrenamiento.
• Entrenamiento, Validación y Prueba: separación de datos.
• Sobreajuste: adaptación excesiva a entrenamiento.
• Regularización: control de la complejidad del modelo.
• Función de Pérdida: cuantificación de errores.
• Retropropagación: cálculo de gradientes.
• Funciones de Activación: ReLU, GELU y otras transformaciones.
• Inicialización de Pesos: configuración inicial del modelo.
• Batch Normalization: normalización por lotes.
• Dropout: regularización estocástica.
• AdamW: optimizador adaptativo.
• Learning Rate Scheduling: modificación programada de la tasa.
• Gradient Clipping: recorte de gradientes.
• Residual Connections: conexiones residuales.
• ResNet: familia de CNN residuales.
• Convolution: convolución.
• Kernel: conjunto de pesos de un filtro.
• Feature Map: mapa de características.
• Stride: desplazamiento.
• Padding: relleno espacial.
• Pooling: agregación local.
• Receptive Field: campo receptivo.
• Depthwise Convolution: convolución por canal.
• Global Average Pooling: promedio espacial por canal.
• Transfer Learning: reutilización de modelos.
• Vision Transformer: arquitectura visual basada en atención.
• Visibilidad en Inteligencia Artificial: medición de presencia, recomendaciones y citas de marcas.

Conclusión

Las Redes Neuronales Convolucionales (Convolutional Neural Networks, CNN) constituyen una de las arquitecturas fundamentales del Deep Learning.

Su principal característica es el aprendizaje de filtros que procesan regiones locales de datos y comparten parámetros entre distintas posiciones.

Este mecanismo permite aprender representaciones visuales progresivamente más complejas.

Las capas iniciales pueden aprender determinados patrones de bajo nivel, mientras que las posteriores combinan características para tareas de clasificación y análisis.

Para comprender correctamente una CNN es esencial conocer los conceptos de Kernel, Feature Map, Stride, Padding, Pooling, Dilation y Receptive Field.

También debemos distinguir las operaciones de convolución o correlación cruzada de las capas completamente conectadas.

Las CNN se utilizan en numerosas arquitecturas, incluidas LeNet, VGG, ResNet, MobileNet y EfficientNet.

Su entrenamiento depende de datos adecuados, una función de pérdida, Backpropagation, un optimizador y una evaluación independiente.

En aplicaciones de AI Visibility pueden servir para analizar activos visuales de marcas, imágenes de productos, logotipos y capturas de sitios web.

Sin embargo, reconocer contenido visual no equivale a medir directamente las recomendaciones de los asistentes de inteligencia artificial.

La conclusión fundamental es que las CNN permiten aprender automáticamente características de datos estructurados mediante filtros locales compartidos. Su importancia reside en ofrecer una arquitectura eficaz y flexible para numerosos problemas de visión artificial, siempre que se seleccione, entrene y valide de acuerdo con las características de la aplicación.