La Arquitectura Faster R-CNN (Faster Region-Based Convolutional Neural Network) es una arquitectura de Deep Learning diseñada para localizar y clasificar objetos individuales dentro de imágenes.

Pertenece a la familia de detectores de objetos basados en regiones, conocidos como Region-Based Object Detectors.

Su característica fundamental es dividir la detección en dos etapas principales.

En la primera etapa, una Region Proposal Network (RPN) identifica regiones que probablemente contienen objetos.

En la segunda, una cabeza de detección examina esas regiones, determina sus categorías y refina sus cajas delimitadoras.

A diferencia de los primeros métodos R-CNN, Faster R-CNN utiliza características convolucionales compartidas entre la generación de propuestas y la detección posterior.

Este diseño permitió reducir considerablemente el coste asociado con las propuestas de regiones.

Faster R-CNN fue presentado en 2015 por Shaoqing Ren, Kaiming He, Ross Girshick y Jian Sun.

Su publicación, Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks, introdujo una Region Proposal Network que aprende a predecir simultáneamente regiones candidatas y puntuaciones de presencia de objetos.

Faster R-CNN sigue siendo una arquitectura importante para comprender la detección moderna de objetos, las redes de dos etapas y los mecanismos de atención espacial basados en regiones.

Entre sus principales aplicaciones están:

• Detección de productos comerciales.
• Reconocimiento de vehículos y personas.
• Inspección industrial.
• Localización de componentes mecánicos.
• Robótica.
• Análisis de imágenes médicas para investigación.
• Procesamiento de imágenes satelitales.
• Detección de objetos en fotografías.
• Conteo visual.
• Investigación en visión por computadora.

Además, la arquitectura Faster R-CNN sirve como base conceptual de Mask R-CNN, que incorpora una rama adicional para segmentación de instancias.

En esta entrada analizaremos sus componentes, el funcionamiento de la RPN, la generación de Anchors, RoI Pooling, RoIAlign, las funciones de pérdida, las métricas de evaluación y varios ejemplos con NumPy, PyTorch y Torchvision.

1. ¿Qué es Faster R-CNN?

Definición breve: Faster R-CNN es una arquitectura de detección de objetos de dos etapas que utiliza una Region Proposal Network para generar regiones candidatas y una segunda etapa para clasificar y refinar las cajas de los objetos.

Su flujo principal es:

Imagen → Backbone → RPN → Propuestas → RoI Head → Objetos detectados

Una predicción final contiene normalmente:

• Caja delimitadora.
• Categoría del objeto.
• Puntuación de confianza.

¿Qué significa Faster?

Hace referencia a la mejora de eficiencia respecto a generaciones anteriores de la familia R-CNN.

¿Es una arquitectura de clasificación?

No exclusivamente.

Realiza conjuntamente localización y clasificación de objetos.

¿Puede detectar varios objetos en la misma imagen?

Sí.

Cada imagen puede producir una colección de detecciones.

2. Evolución de R-CNN a Faster R-CNN

Para comprender Faster R-CNN conviene estudiar su evolución.

R-CNN — 2014

Utilizaba propuestas de regiones externas y ejecutaba una CNN sobre las regiones propuestas.

Fast R-CNN — 2015

Procesaba la imagen completa para obtener características compartidas, pero seguía dependiendo de propuestas externas.

Faster R-CNN — 2015

Incorporó una Region Proposal Network para aprender las propuestas dentro del sistema.

Comparación

¿Cuál fue la innovación fundamental?

Integrar la generación de propuestas con la detección mediante un backbone compartido.

3. ¿Qué son los detectores de dos etapas?

Los Two-Stage Object Detectors dividen el procesamiento en dos componentes conceptuales.

Primera etapa

Identificar regiones candidatas.

Segunda etapa

Clasificar esas regiones y refinar sus localizaciones.

Ejemplo

Una imagen contiene tres vehículos y una persona.

La RPN propone regiones posiblemente relevantes.

La segunda etapa transforma esas propuestas en predicciones con categorías y cajas refinadas.

¿Todas las propuestas son objetos reales?

No.

Algunas son regiones de fondo o candidatos incorrectos.

4. Faster R-CNN frente a YOLO

Faster R-CNN y YOLO representan estrategias diferentes.

¿Faster R-CNN siempre es más preciso?

No.

¿YOLO siempre es más rápido?

Tampoco.

La comparación debe realizarse entre versiones concretas y bajo las mismas condiciones.

5. ¿Qué es el Backbone de Faster R-CNN?

El Backbone es una red neuronal que transforma una imagen en mapas de características.

Entre los backbones utilizados históricamente se encuentran:

• VGG.
• ResNet.
• Arquitecturas convolucionales personalizadas.

Una configuración moderna conocida utiliza:

ResNet-50 + FPN

¿Qué hace ResNet-50?

Extrae representaciones visuales mediante bloques residuales.

¿Qué aporta FPN?

Combina características de distintas escalas para facilitar la detección de objetos de diferentes tamaños.

6. ¿Qué son los Feature Maps?

Los Feature Maps son tensores que representan características aprendidas de la imagen.

Supongamos una entrada:

[1, 3, 800, 800]

El backbone puede producir mapas con diferentes canales y resoluciones.

¿Por qué se reduce la resolución?

Porque las operaciones convolucionales con Stride y Pooling pueden reducir el tamaño espacial.

¿Qué información contienen?

Representaciones visuales útiles para identificar bordes, texturas, formas y patrones de nivel superior.

¿Son iguales que la imagen RGB?

No.

Son representaciones aprendidas.

7. ¿Qué es Region Proposal Network?

La Region Proposal Network (RPN) es una pequeña red neuronal que opera sobre mapas de características para generar candidatos de objetos.

Para cada posición y referencia espacial relevante puede producir:

1. Una puntuación de Objectness.
2. Parámetros para ajustar una Bounding Box.

¿Qué significa Objectness?

Es la estimación de si una región contiene un objeto, sin determinar todavía su categoría final específica.

¿La RPN clasifica automóviles, personas y bicicletas?

En su formulación habitual no.

Su tarea es distinguir propuestas con objetos frente a regiones de fondo.

La clasificación multiclase se realiza en la segunda etapa.

8. ¿Cómo funciona la RPN?

Una formulación clásica utiliza una convolución compartida seguida de dos ramas de predicción.

Rama de Objectness

Produce puntuaciones para los Anchors.

Rama de regresión

Predice desplazamientos y cambios de tamaño de las cajas.

El esquema es:

Feature Maps → Conv3×3 → Objectness + Box Regression

¿Por qué comparten características?

Para reducir cómputo redundante y permitir el aprendizaje conjunto.

9. ¿Qué son Anchor Boxes?

Los Anchor Boxes son cajas de referencia utilizadas para generar regiones candidatas.

Para una posición del mapa de características podemos definir diferentes:

• Escalas.
• Anchuras.
• Alturas.
• Proporciones.

Ejemplo

Tres escalas:

128, 256 y 512

Tres proporciones:

1:1, 1:2 y 2:1

Una combinación clásica genera:

3 × 3 = 9 Anchors por posición.

¿Todos los Faster R-CNN utilizan exactamente nueve?

No.

La cantidad y geometría dependen de la configuración.

En modelos con FPN pueden distribuirse diferentes tamaños de referencia entre niveles.

10. ¿Cómo se calcula una Anchor Box?

Si definimos un área nominal A y una proporción:

r = anchura / altura

podemos calcular:

Anchura = √(Ar)

Altura = √(A/r)

Ejemplo

Área:

A = 128²

Proporción:

r = 2

La anchura es aproximadamente:

181,02

La altura es aproximadamente:

90,51

¿Qué representa?

Una caja horizontal con proporción anchura/altura igual a dos.

11. Ejemplo 1 — Generar Anchors con Python

import math
def create_anchors(
    center_x,
    center_y,
    sizes,
    aspect_ratios
):
    anchors = []
    for size in sizes:
        area = size ** 2
        for ratio in aspect_ratios:
            width = math.sqrt(
                area * ratio
            )
            height = math.sqrt(
                area / ratio
            )
            anchors.append([
                center_x - width / 2,
                center_y - height / 2,
                center_x + width / 2,
                center_y + height / 2
            ])
    return anchors
anchors = create_anchors(
    center_x=256,
    center_y=256,
    sizes=[64, 128, 256],
    aspect_ratios=[0.5, 1.0, 2.0]
)
print(
    "Número de Anchors:",
    len(anchors)
)
for anchor in anchors[:3]:
    print(

[round(v, 2) for v in anchor]

)

Resultado esperado

9 Anchors

¿Qué demuestra?

Podemos construir múltiples cajas de referencia a partir de combinaciones de escalas y proporciones.

12. ¿Cuántos Anchors genera una RPN?

Si un mapa de características tiene:

H × W posiciones

y se utilizan:

A Anchors por posición

el número de referencias es:

N = H × W × A

Ejemplo

Mapa:

50 × 50

Anchors por posición:

9

Resultado:

50 × 50 × 9 = 22.500 Anchors

¿Significa que se envían 22.500 propuestas a la segunda etapa?

No necesariamente.

La RPN filtra, ordena y reduce candidatos.

13. Ejemplo 2 — Número de Anchors

def count_anchors(
    height,
    width,
    anchors_per_location
):
    return (
        height
        * width
        * anchors_per_location
    )
print(
    count_anchors(
        height=50,
        width=50,
        anchors_per_location=9
    )
)

Resultado esperado:

22500

14. ¿Cómo aprende la RPN cuáles Anchors son positivos?

Durante entrenamiento se comparan las Anchors con las cajas reales mediante un criterio como Intersection over Union.

En una configuración habitual:

• Anchors con IoU elevado pueden asignarse como positivos.
• Anchors con IoU bajo pueden asignarse como negativos.
• Anchors intermedios pueden ignorarse.

¿Cuáles son los umbrales?

Dependen de la implementación.

En configuraciones conocidas de Faster R-CNN pueden aparecer valores como:

0,7 para positivos y 0,3 para negativos, junto con reglas adicionales que aseguran asociaciones con las cajas reales.

¿Son umbrales universales?

No.

No deben confundirse con el IoU de evaluación ni con el umbral de NMS.

15. ¿Qué es Intersection over Union?

Intersection over Union (IoU) mide el solapamiento entre dos cajas.

Fórmula

IoU = Área de intersección / Área de unión

Donde:

Unión = Área A + Área B − Intersección

Interpretación

• IoU = 0: sin solapamiento.
• IoU = 1: coincidencia perfecta.
• Valores intermedios: diferentes grados de coincidencia.

16. Ejemplo 3 — Calcular IoU con NumPy

import numpy as np
def box_iou(box_a, box_b):
    x1 = max(
        box_a[0],
        box_b[0]
    )
    y1 = max(
        box_a[1],
        box_b[1]
    )
    x2 = min(
        box_a[2],
        box_b[2]
    )
    y2 = min(
        box_a[3],
        box_b[3]
    )
    intersection = (
        max(0, x2 - x1)
        * max(0, y2 - y1)
    )
    area_a = (
        max(0, box_a[2] - box_a[0])
        * max(0, box_a[3] - box_a[1])
    )
    area_b = (
        max(0, box_b[2] - box_b[0])
        * max(0, box_b[3] - box_b[1])
    )
    union = (
        area_a
        + area_b
        - intersection
    )
    return (
        intersection / union
        if union > 0
        else 0.0
    )
box_a = [0, 0, 100, 100]
box_b = [25, 0, 125, 100]
print(
    round(box_iou(box_a, box_b), 3)
)

Resultado esperado:

0,6

17. ¿Cómo funciona la regresión de cajas?

La RPN no necesita predecir siempre una caja completa desde cero.

En su formulación clásica, aprende transformaciones relativas a una Anchor Box.

Sea una Anchor con:

• Centro xa, ya.
• Anchura wa.
• Altura ha.

Y una caja real con:

• Centro x, y.
• Anchura w.
• Altura h.

Los objetivos pueden representarse como:

tx = (x − xa) / wa

ty = (y − ya) / ha

tw = log(w / wa)

th = log(h / ha)

¿Por qué utilizar logaritmos?

Porque los cambios relativos de anchura y altura pueden representarse mediante relaciones de escala.

18. Ejemplo 4 — Codificar desplazamientos de cajas

import math
def encode_box(anchor, target):
    ax1, ay1, ax2, ay2 = anchor
    tx1, ty1, tx2, ty2 = target
    aw = ax2 - ax1
    ah = ay2 - ay1
    tw = tx2 - tx1
    th = ty2 - ty1
    if min(aw, ah, tw, th) <= 0:
        raise ValueError(
            "Las cajas deben tener dimensiones positivas"
        )
    acx = (ax1 + ax2) / 2
    acy = (ay1 + ay2) / 2
    tcx = (tx1 + tx2) / 2
    tcy = (ty1 + ty2) / 2
    return [
        (tcx - acx) / aw,
        (tcy - acy) / ah,
        math.log(tw / aw),
        math.log(th / ah)
    ]
anchor = [50, 50, 150, 150]
target = [60, 55, 180, 155]
print(

[round(v, 4) for v in encode_box(anchor, target)]

)

¿Qué demuestra?

Una Bounding Box puede representarse mediante desplazamientos y escalados respecto a una referencia.

Precaución

Implementaciones como Torchvision pueden aplicar factores de ponderación adicionales a los parámetros codificados.

19. ¿Cómo genera propuestas la RPN?

Después de obtener puntuaciones y desplazamientos, la RPN realiza operaciones como:

1. Decodificar las cajas.
2. Recortar cajas a los límites válidos de la imagen.
3. Eliminar cajas demasiado pequeñas.
4. Ordenar por Objectness.
5. Seleccionar candidatos.
6. Aplicar NMS.
7. Conservar un número limitado de propuestas.

¿Por qué filtrar?

Porque el número inicial de Anchors puede ser elevado.

¿Las propuestas ya tienen categoría final?

No.

Normalmente representan regiones que podrían contener objetos.

20. ¿Qué es Non-Maximum Suppression?

Non-Maximum Suppression (NMS) reduce propuestas que se solapan excesivamente.

Proceso

1. Seleccionar la caja con mayor puntuación.
2. Compararla con las demás.
3. Eliminar cajas cuyo solapamiento supere el criterio elegido.
4. Repetir.

¿Se aplica NMS únicamente al final de Faster R-CNN?

No.

En configuraciones típicas puede aplicarse tanto para filtrar propuestas de la RPN como para reducir detecciones finales de la segunda etapa.

¿Se utilizan necesariamente los mismos umbrales?

No.

21. Ejemplo 5 — NMS con Torchvision

import torch
from torchvision.ops import nms
boxes = torch.tensor([
    [10., 10., 100., 100.],
    [15., 15., 105., 105.],
    [160., 20., 240., 110.]
])
scores = torch.tensor([
    0.96,
    0.88,
    0.91
])
selected = nms(
    boxes,
    scores,
    iou_threshold=0.5
)
print(
    selected.tolist()
)

Resultado esperado:

[0, 2]

¿Qué demuestra?

Dos cajas muy similares pueden representar un mismo objeto y ser reducidas mediante NMS.

22. ¿Qué es la segunda etapa de Faster R-CNN?

La segunda etapa recibe las propuestas seleccionadas y las características correspondientes.

Su finalidad es:

• Clasificar las propuestas.
• Rechazar regiones de fondo.
• Refinar las coordenadas de las cajas.

¿Cómo obtiene características de cada propuesta?

Mediante operaciones de extracción de regiones de interés.

Históricamente se utilizó RoI Pooling.

En implementaciones modernas es frecuente utilizar RoIAlign.

23. ¿Qué es Region of Interest?

Una Region of Interest (RoI) es una región espacial candidata.

Puede representarse mediante una Bounding Box.

¿Qué problema existe?

Las propuestas tienen tamaños diferentes.

Una puede medir 50 × 80 píxeles.

Otra puede medir 200 × 300.

Sin embargo, las capas posteriores suelen necesitar tensores de dimensiones controladas.

¿Qué solución se utiliza?

RoI Pooling o RoIAlign.

24. ¿Qué es RoI Pooling?

RoI Pooling extrae características de regiones de tamaño variable y produce representaciones de tamaño fijo.

Ejemplo

Una región de una imagen puede corresponder a un mapa de características de tamaño variable.

RoI Pooling produce una salida fija, como:

7 × 7

¿Por qué es útil?

Permite utilizar una misma cabeza de clasificación sobre propuestas de distintos tamaños.

¿Qué inconveniente puede existir?

Las cuantizaciones espaciales pueden introducir errores de alineación.

25. ¿Qué es RoIAlign?

RoIAlign utiliza muestreo e interpolación para reducir errores de alineación asociados a determinadas cuantizaciones.

¿Fue parte de Faster R-CNN en 2015?

No en su formulación original.

RoIAlign fue presentado posteriormente con Mask R-CNN en 2017.

¿Por qué aparece en implementaciones modernas de Faster R-CNN?

Porque mejora el tratamiento de coordenadas continuas y puede utilizarse como componente de extracción de regiones.

¿Es una operación que detecta objetos?

No.

Extrae características para que las utilicen las cabezas posteriores.

26. RoI Pooling frente a RoIAlign

¿RoIAlign es siempre superior?

No puede garantizarse en todas las configuraciones.

Pero su mayor precisión de alineación resulta especialmente útil en tareas espaciales.

27. Ejemplo 6 — RoIAlign con PyTorch

import torch
from torchvision.ops import roi_align
features = torch.arange(
    0,
    16 * 16,
    dtype=torch.float32
).reshape(
    1, 1, 16, 16
)
boxes = [
    torch.tensor([
        [2.5, 2.5, 12.5, 12.5]
    ])
]
pooled = roi_align(
    features,
    boxes,
    output_size=(7, 7),
    spatial_scale=1.0,
    sampling_ratio=2,
    aligned=True
)
print(
    "Entrada:",
    features.shape
)
print(
    "Salida:",
    pooled.shape
)

Resultado esperado:

Entrada: torch.Size([1, 1, 16, 16])
Salida: torch.Size([1, 1, 7, 7])

¿Qué demuestra?

Podemos extraer una representación espacial fija de una región de tamaño variable.

¿Qué significa spatial_scale?

Relaciona la escala de las coordenadas de las cajas con la escala del mapa de características.

Si las cajas están definidas sobre una imagen mayor que el mapa, debemos utilizar el factor apropiado.

28. ¿Qué es Feature Pyramid Network?

Feature Pyramid Network (FPN) combina representaciones de diferentes resoluciones.

¿Por qué se utiliza?

Porque los objetos pueden ocupar diferentes tamaños.

Ejemplo

En una fotografía podemos encontrar:

• Una señal pequeña.
• Un automóvil.
• Un autobús.

¿Qué aporta FPN?

Mapas multiescala con información semántica útil para detectar objetos en diferentes niveles.

¿El Faster R-CNN original tenía FPN?

No.

FPN fue presentado posteriormente y forma parte de numerosas configuraciones modernas.

29. ¿Qué significa Faster R-CNN ResNet-50-FPN?

Describe una configuración de Faster R-CNN que utiliza:

• ResNet-50 como backbone.
• FPN para características multiescala.
• RPN para propuestas.
• RoI Heads para clasificación y regresión.

¿Es una arquitectura única sin variantes?

No.

Existen diferentes procedimientos de entrenamiento, versiones y configuraciones.

¿Qué ofrece Torchvision?

Entre otras opciones:

• fasterrcnn_resnet50_fpn
• fasterrcnn_resnet50_fpn_v2

30. ¿Qué produce la segunda etapa?

La cabeza final puede devolver:

boxes

Coordenadas de las cajas refinadas.

labels

Identificadores de categoría.

scores

Puntuaciones de confianza.

Ejemplo

Una imagen contiene dos objetos detectados.

boxes:
    [40, 50, 150, 170]
    [230, 80, 340, 190]
labels:
    1
    3
scores:
    0.97
    0.89

¿Qué diferencia existe respecto a las propuestas RPN?

Las detecciones finales incluyen clasificación semántica específica.

31. ¿Cómo se entrena Faster R-CNN?

Faster R-CNN optimiza varios componentes.

La RPN aprende a generar propuestas.

La cabeza de detección aprende a clasificar y refinar cajas.

Pérdidas conceptuales

Ltotal = LRPN + LRoI

Podemos descomponer:

LRPN = Lobjectness + Lrpn_box

LRoI = Lclassification + Lbox_regression

¿La fórmula es universal para todas las implementaciones?

Es una descomposición conceptual representativa.

Los términos, normalizaciones y pesos exactos dependen de la implementación.

32. ¿Qué es Objectness Loss?

La Objectness Loss penaliza errores al distinguir propuestas positivas y negativas.

¿Qué pregunta responde la RPN?

«¿Esta región probablemente contiene un objeto?»

¿Qué tipo de pérdida puede utilizarse?

Una formulación de clasificación binaria, como Binary Cross-Entropy sobre logits.

¿Es una clasificación multiclase?

No.

La categorización específica corresponde a la segunda etapa.

33. ¿Qué es Box Regression Loss?

La Box Regression Loss mide el error en los parámetros que ajustan las cajas.

Una función clásica es Smooth L1.

¿Por qué se utiliza?

Porque ofrece una transición entre comportamiento cuadrático para errores pequeños y aproximadamente lineal para errores mayores.

¿Se utiliza siempre Smooth L1?

No.

Existen implementaciones y arquitecturas que utilizan otras pérdidas geométricas.

34. ¿Qué es RoI Classification Loss?

La cabeza de clasificación predice categorías para las regiones propuestas.

Puede incluir una categoría de fondo.

¿Qué diferencia existe con Objectness?

Objectness distingue regiones con objetos frente a fondo.

La clasificación RoI decide a qué categoría pertenece cada propuesta.

¿Por qué puede aparecer fondo en la segunda etapa?

Porque algunas propuestas no corresponden a ningún objeto verdadero.

35. ¿Cómo se asignan propuestas a objetos verdaderos?

Durante entrenamiento, las propuestas se comparan con las cajas anotadas.

Objetivos

• Identificar propuestas positivas.
• Identificar negativas.
• Asignar categorías.
• Calcular objetivos de regresión.

¿Se utiliza IoU?

Sí, en los esquemas habituales.

¿Todos los Anchors o propuestas se utilizan para calcular todas las pérdidas?

No.

Pueden aplicarse muestreos y reglas para positivos, negativos y candidatos ignorados.

36. ¿Qué es Positive/Negative Sampling?

Un detector puede generar muchas más regiones de fondo que regiones con objetos.

Problema

El entrenamiento puede quedar dominado por ejemplos negativos.

Solución

Utilizar estrategias de muestreo que controlen la proporción de ejemplos positivos y negativos.

¿Qué ocurre si no hay suficientes positivos?

La implementación debe manejar el caso adecuadamente.

¿Los ratios son universales?

No.

Dependen del componente y de la configuración.

37. ¿Qué métricas se utilizan para evaluar Faster R-CNN?

Las métricas principales incluyen:

• Precision.
• Recall.
• Average Precision.
• Mean Average Precision.
• AP50.
• AP75.
• AP para objetos pequeños, medianos y grandes.

¿Qué evalúa IoU?

La geometría del solapamiento de una detección respecto a una caja real.

¿Qué evalúa AP?

La relación Precision-Recall bajo reglas definidas de emparejamiento.

38. ¿Qué significa mAP50-95?

Es una métrica utilizada en evaluaciones tipo COCO.

Se agrega AP sobre umbrales IoU:

0,50 a 0,95 en incrementos de 0,05.

¿Por qué utiliza varios umbrales?

Porque diferencia detecciones aproximadas de localizaciones más precisas.

¿Puede compararse directamente con AP50?

No.

El protocolo de agregación es diferente.

39. ¿Qué es Transfer Learning con Faster R-CNN?

Transfer Learning permite reutilizar un detector entrenado sobre un dataset anterior.

Por ejemplo, un checkpoint entrenado en COCO puede proporcionar características útiles para detectar productos de una empresa.

¿Qué debemos modificar?

Normalmente, la cabeza final para que tenga el número de categorías de la nueva tarea.

¿Es necesario entrenar de nuevo?

Sí.

La nueva cabeza contiene parámetros que deben aprenderse.

40. Ejemplo 7 — Instalar PyTorch y Torchvision

Para empezar necesitamos una instalación compatible de PyTorch y Torchvision.

Una vez configurado el entorno, podemos comprobarlo con:

import torch
import torchvision
print(
    "PyTorch:",
    torch.__version__
)
print(
    "Torchvision:",
    torchvision.__version__
)
print(
    "CUDA disponible:",
    torch.cuda.is_available()
)

¿Por qué revisar versiones?

Porque Torchvision incluye operadores compilados, como NMS y RoIAlign, que deben ser compatibles con la instalación de PyTorch.

¿Podemos ejecutar Faster R-CNN en CPU?

Sí.

Sin embargo, el entrenamiento y la inferencia pueden ser más lentos que en una GPU adecuada.

41. Ejemplo 8 — Cargar Faster R-CNN preentrenado

import torch
from torchvision.models.detection import (
    fasterrcnn_resnet50_fpn_v2,
    FasterRCNN_ResNet50_FPN_V2_Weights
)
weights = (
    FasterRCNN_ResNet50_FPN_V2_Weights.DEFAULT
)
model = fasterrcnn_resnet50_fpn_v2(
    weights=weights
)
model.eval()
parameters = sum(
    p.numel()
    for p in model.parameters()
)
print(
    f"Parámetros: {parameters / 1e6:.2f} M"
)

¿Qué demuestra?

Podemos cargar una implementación moderna de Faster R-CNN basada en ResNet-50 y FPN.

¿Qué tamaño tiene aproximadamente?

La variante V2 documentada por Torchvision utiliza alrededor de 43,7 millones de parámetros.

¿Es necesaria una conexión a Internet?

Puede ser necesaria para descargar los pesos la primera vez.

42. Ejemplo 9 — Ejecutar inferencia en una imagen

import torch
from PIL import Image
from torchvision.models.detection import (
    fasterrcnn_resnet50_fpn_v2,
    FasterRCNN_ResNet50_FPN_V2_Weights
)
weights = (
    FasterRCNN_ResNet50_FPN_V2_Weights.DEFAULT
)
model = fasterrcnn_resnet50_fpn_v2(
    weights=weights
)
model.eval()
image = Image.open(
    "imagen.jpg"
).convert("RGB")
preprocess = weights.transforms()
image_tensor = preprocess(
    image
)
with torch.inference_mode():
    predictions = model([
        image_tensor
    ])
result = predictions[0]
print(
    "Cajas:",
    result["boxes"].shape
)
print(
    "Etiquetas:",
    result["labels"].shape
)
print(
    "Puntuaciones:",
    result["scores"].shape
)

¿Qué demuestra?

La inferencia produce una colección de objetos detectados.

¿Por qué utilizar weights.transforms()?

Porque aplica el preprocesamiento previsto para el checkpoint.

43. Ejemplo 10 — Filtrar detecciones

score_threshold = 0.70
keep = (
    result["scores"]
    >= score_threshold
)
boxes = result["boxes"][keep]
labels = result["labels"][keep]
scores = result["scores"][keep]
print(
    "Detecciones conservadas:",
    len(boxes)
)

¿Qué significa el umbral?

Determina qué detecciones se conservan según su puntuación.

¿Un umbral más alto siempre mejora?

No.

Puede reducir falsos positivos, pero también eliminar objetos reales.

44. Ejemplo 11 — Mostrar las categorías detectadas

categories = weights.meta[
    "categories"
]
for label, score, box in zip(
    labels.cpu().tolist(),
    scores.cpu().tolist(),
    boxes.cpu().tolist()
):
    if 0 <= label < len(categories):
        name = categories[label]
    else:
        name = f"Clase {label}"
    print(
        "Objeto:",
        name
    )
    print(
        "Puntuación:",
        round(score, 3)
    )
    print(
        "Caja:",
        box
    )

¿Qué demuestra?

Podemos transformar las salidas del detector en datos estructurados.

¿Puede reconocer automáticamente cualquier SKU comercial?

No.

Las categorías del checkpoint pueden no coincidir con las del catálogo de una empresa.

45. Ejemplo 12 — Dibujar Bounding Boxes

import matplotlib.pyplot as plt
from torchvision.utils import (
    draw_bounding_boxes
)
from torchvision.transforms.functional import (
    pil_to_tensor
)
image_tensor_uint8 = pil_to_tensor(
    image
)
box_labels = [
    f"{categories[label.item()]} "
    f"{score.item():.2f}"
    for label, score in zip(
        labels,
        scores
    )
]
visualization = draw_bounding_boxes(
    image_tensor_uint8,
    boxes=boxes.cpu(),
    labels=box_labels,
    width=3
)
plt.figure(figsize=(10, 7))
plt.imshow(
    visualization.permute(
        1, 2, 0
    ).numpy()
)
plt.axis("off")
plt.show()

¿Qué demuestra?

Podemos representar visualmente los resultados para depurar o presentar una aplicación.

46. ¿Cómo adaptar Faster R-CNN a clases propias?

Supongamos que una empresa necesita reconocer:

1. Botellas.
2. Cajas.

En Torchvision normalmente se necesita un total de:

3 clases

porque el identificador cero representa fondo.

¿Qué debemos cambiar?

El predictor final de la RoI Head.

¿Podemos reutilizar el backbone?

Sí.

Podemos conservar los pesos preentrenados y adaptar el clasificador.

47. Ejemplo 13 — Sustituir el predictor

from torchvision.models.detection import (
    fasterrcnn_resnet50_fpn,
    FasterRCNN_ResNet50_FPN_Weights
)
from torchvision.models.detection.faster_rcnn import (
    FastRCNNPredictor
)
model = fasterrcnn_resnet50_fpn(
    weights=FasterRCNN_ResNet50_FPN_Weights.DEFAULT
)
# Fondo + botella + caja
num_classes = 3
in_features = (
    model.roi_heads.box_predictor
    .cls_score.in_features
)
model.roi_heads.box_predictor = (
    FastRCNNPredictor(
        in_features,
        num_classes
    )
)
print(
    model.roi_heads.box_predictor
)

¿Qué demuestra?

Podemos adaptar un detector preentrenado a nuevas categorías.

¿La nueva cabeza ya reconoce botellas y cajas?

No.

Sus nuevos parámetros deben entrenarse con datos etiquetados.

48. ¿Qué formato de datos necesita Torchvision?

Cada muestra de entrenamiento contiene una imagen y un diccionario de anotaciones.

La imagen tiene normalmente forma:

[3, H, W]

Las cajas:

[N, 4]

Las etiquetas:

[N]

Campos frecuentes

• boxes.
• labels.
• image_id.
• area.
• iscrowd.

¿Las imágenes pueden contener diferentes cantidades de objetos?

Sí.

Por eso los DataLoaders suelen necesitar una función de agrupación específica.

49. Ejemplo 14 — Crear un Dataset sintético de detección

Construiremos un conjunto educativo con un rectángulo y un círculo por imagen.

La finalidad es comprobar el formato de datos y el proceso de entrenamiento.

import numpy as np
import torch
from torch.utils.data import Dataset
class ShapesDetectionDataset(Dataset):
    def __init__(
        self,
        count=50,
        size=128,
        seed=42
    ):
        self.count = count
        self.size = size
        self.seed = seed
    def __len__(self):
        return self.count
    def __getitem__(self, index):
        rng = np.random.default_rng(
            self.seed + index
        )
        size = self.size
        image = np.zeros(
            (size, size, 3),
            dtype=np.float32
        )
        # Clase 1: rectángulo
        x1 = int(rng.integers(8, 30))
        y1 = int(rng.integers(8, 30))
        x2 = x1 + 30
        y2 = y1 + 25
        image[
            y1:y2,
            x1:x2,
            0
        ] = 0.9
        # Clase 2: círculo
        cx = int(rng.integers(75, 105))
        cy = int(rng.integers(75, 105))
        radius = 12
        yy, xx = np.ogrid[
            :size,
            :size
        ]
        circle = (
            (xx - cx)**2
            + (yy - cy)**2
            <= radius**2
        )
        image[circle, 1] = 0.9
        boxes = torch.tensor(
            [
                [x1, y1, x2, y2],
                [
                    cx - radius,
                    cy - radius,
                    cx + radius + 1,
                    cy + radius + 1
                ]
            ],
            dtype=torch.float32
        )
        labels = torch.tensor(
            [1, 2],
            dtype=torch.int64
        )
        tensor_image = torch.from_numpy(
            image.transpose(2, 0, 1)
        ).float()
        areas = (
            (boxes[:, 2] - boxes[:, 0])
            * (boxes[:, 3] - boxes[:, 1])
        )
        target = {
            "boxes": boxes,
            "labels": labels,
            "image_id": torch.tensor(index),
            "area": areas,
            "iscrowd": torch.zeros(
                2,
                dtype=torch.int64
            )
        }
        return tensor_image, target

¿Qué demuestra?

Las imágenes contienen objetos visualmente relacionados con las etiquetas.

¿Es un dataset realista?

No.

Es sintético y muy sencillo.

50. Ejemplo 15 — Crear DataLoaders

from torch.utils.data import DataLoader
def detection_collate(batch):
    images, targets = zip(*batch)
    return (
        list(images),
        list(targets)
    )
train_dataset = ShapesDetectionDataset(
    count=50,
    seed=10
)
val_dataset = ShapesDetectionDataset(
    count=10,
    seed=1000
)
train_loader = DataLoader(
    train_dataset,
    batch_size=2,
    shuffle=True,
    collate_fn=detection_collate
)
val_loader = DataLoader(
    val_dataset,
    batch_size=2,
    shuffle=False,
    collate_fn=detection_collate
)

¿Por qué utilizar collate_fn?

Porque cada imagen puede tener un número diferente de cajas.

51. Ejemplo 16 — Entrenar Faster R-CNN

El siguiente ejemplo utiliza el modelo con tres categorías configurado anteriormente.

import torch
device = torch.device(
    "cuda" if torch.cuda.is_available()
    else "cpu"
)
model = model.to(device)
optimizer = torch.optim.SGD(
    [
        parameter
        for parameter in model.parameters()
        if parameter.requires_grad
    ],
    lr=0.001,
    momentum=0.9,
    weight_decay=0.0005
)
for epoch in range(2):
    model.train()
    total_loss = 0.0
    for images, targets in train_loader:
        images = [
            image.to(device)
            for image in images
        ]
        targets = [
            {
                key: value.to(device)
                for key, value in target.items()
            }
            for target in targets
        ]
        optimizer.zero_grad()
        loss_dict = model(
            images,
            targets
        )
        loss = sum(
            loss_dict.values()
        )
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(
        "Época:",
        epoch + 1,
        "Pérdida acumulada:",
        round(total_loss, 4)
    )

¿Qué demuestra?

Faster R-CNN puede entrenarse mediante la suma de pérdidas de la RPN y de la RoI Head.

Precaución

El modelo puede requerir memoria considerable.

Dos épocas sobre un dataset sintético no proporcionan un detector listo para producción.

52. ¿Cómo visualizar las pérdidas?

Durante entrenamiento, Torchvision devuelve un diccionario de pérdidas.

En configuraciones habituales podemos encontrar:

• loss_classifier.
• loss_box_reg.
• loss_objectness.
• loss_rpn_box_reg.

¿Qué significa cada una?

loss_classifier: error de clasificación de la segunda etapa.

loss_box_reg: error de regresión de cajas finales.

loss_objectness: error de clasificación de propuestas.

loss_rpn_box_reg: error de regresión de Anchors.

¿Qué debemos hacer?

Registrar estas métricas durante entrenamiento y analizarlas junto con las métricas de validación.

53. Ejemplo 17 — Inspeccionar las pérdidas

model.train()
images, targets = next(
    iter(train_loader)
)
images = [
    image.to(device)
    for image in images
]
targets = [
    {
        key: value.to(device)
        for key, value in target.items()
    }
    for target in targets
]
losses = model(
    images,
    targets
)
for name, value in losses.items():
    print(
        name,
        round(float(value.detach()), 4)
    )

¿Qué demuestra?

Podemos conocer qué componentes contribuyen al entrenamiento.

¿Una pérdida baja garantiza un mAP alto?

No.

Las pérdidas y las métricas de detección miden aspectos diferentes.

54. ¿Cómo evaluar Faster R-CNN?

La evaluación debe utilizar un conjunto de datos separado del entrenamiento.

Métricas importantes

• AP50.
• AP75.
• COCO mAP.
• Precision.
• Recall.
• Resultados por clase.
• Resultados por tamaño de objeto.

¿Por qué no basta con la pérdida de validación?

Porque el objetivo final es detectar objetos correctamente.

¿Qué herramienta podemos utilizar?

TorchMetrics proporciona MeanAveragePrecision para evaluaciones de detección.

55. Ejemplo 18 — Calcular mAP con TorchMetrics

Instalación orientativa:

pip install torchmetrics pycocotools

Código:

from torchmetrics.detection.mean_ap import (
    MeanAveragePrecision
)
metric = MeanAveragePrecision(
    box_format="xyxy",
    iou_type="bbox"
)
model.eval()
with torch.inference_mode():
    for images, targets in val_loader:
        images_device = [
            image.to(device)
            for image in images
        ]
        predictions = model(
            images_device
        )
        predictions_cpu = [
            {
                key: value.detach().cpu()
                for key, value in prediction.items()
            }
            for prediction in predictions
        ]
        targets_cpu = [
            {
                key: value.cpu()
                for key, value in target.items()
            }
            for target in targets
        ]
        metric.update(
            predictions_cpu,
            targets_cpu
        )
metrics = metric.compute()
print(
    "mAP50:",
    float(metrics["map_50"])
)
print(
    "mAP50-95:",
    float(metrics["map"])
)

¿Qué demuestra?

Podemos evaluar las detecciones mediante un procedimiento relacionado con COCO AP.

¿Por qué utilizar un conjunto independiente?

Para medir la capacidad de generalización sobre imágenes no utilizadas para ajustar el modelo.

56. ¿Cómo guardar un modelo entrenado?

Podemos guardar los parámetros mediante state_dict().

torch.save(
    model.state_dict(),
    "faster_rcnn_custom.pt"
)

¿Cómo recuperarlo?

Debemos reconstruir la misma arquitectura y cargar los parámetros.

model.load_state_dict(
    torch.load(
        "faster_rcnn_custom.pt",
        map_location="cpu",
        weights_only=True
    )
)
model.eval()

¿Qué debemos conservar además?

• Definición de arquitectura.
• Nombres de clases.
• Preprocesamiento.
• Versiones de dependencias.
• Configuración de entrenamiento.

57. ¿Cómo funciona Faster R-CNN con imágenes de distintos tamaños?

Las implementaciones de Torchvision admiten listas de imágenes que pueden tener dimensiones diferentes.

Ejemplo

Una imagen:

640 × 480

Otra:

800 × 600

¿Qué hace el modelo?

Su mecanismo de transformación interna puede redimensionar y organizar las imágenes según la configuración.

¿Las cajas finales corresponden a las coordenadas originales?

En la API estándar de Torchvision, el posprocesamiento devuelve las cajas en el sistema de coordenadas de la imagen suministrada.

¿Por qué importa?

Porque necesitamos dibujar o utilizar las cajas en la imagen correcta.

58. ¿Qué es Transfer Learning frente a Fine-Tuning?

Transfer Learning es reutilizar conocimientos aprendidos previamente.

Fine-Tuning es adaptar pesos preentrenados mediante entrenamiento adicional.

Ejemplo

Un detector COCO aprende representaciones generales de objetos.

Una empresa quiere detectar componentes eléctricos.

Podemos:

1. Cargar el detector.
2. Sustituir la cabeza.
3. Entrenar con imágenes anotadas.
4. Ajustar determinadas capas.
5. Evaluar resultados.

¿Es obligatorio entrenar el backbone completo?

No.

Puede congelarse parcial o totalmente según los datos y recursos.

59. ¿Qué es Small Object Detection?

Los objetos pequeños presentan desafíos especiales.

Ejemplo

Una imagen contiene pequeños conectores sobre una placa electrónica.

¿Qué dificultades aparecen?

• Pocas posiciones espaciales.
• Variaciones de escala.
• Detalles limitados.
• Cajas imprecisas.
• Oclusiones.

¿Cómo ayudar?

• Utilizar FPN.
• Mejorar resolución.
• Recortar imágenes grandes.
• Ajustar tamaños de Anchors.
• Utilizar anotaciones de calidad.

¿Es suficiente aumentar Anchors?

No.

La capacidad de detección depende del conjunto completo de arquitectura, datos y entrenamiento.

60. ¿Qué es el problema de objetos grandes?

Los objetos grandes pueden extenderse por una parte considerable de la imagen.

¿Qué desafíos aparecen?

• Objetos parcialmente visibles.
• Regiones que exceden el encuadre.
• Cajas muy grandes.
• Pérdida de contexto en recortes.

¿Cómo abordarlo?

Utilizando características multiescala y datos representativos.

61. ¿Qué es la oclusión?

Occlusion ocurre cuando un objeto oculta parcialmente otro.

Ejemplo

Una persona aparece detrás de un automóvil.

¿Qué dificultad produce?

El detector recibe información visual incompleta.

¿Puede Faster R-CNN detectar objetos ocluidos?

Sí, en determinadas condiciones, pero depende de su entrenamiento.

¿Cómo debemos evaluarlo?

Incluyendo imágenes con diferentes grados de oclusión.

62. ¿Cómo medir la latencia?

Un detector debe evaluarse en el hardware objetivo.

Métricas

• Tiempo por imagen.
• Throughput.
• Consumo de memoria.
• Resolución de entrada.
• Uso de CPU/GPU.
• Coste del posprocesamiento.

¿Faster R-CNN es adecuado para tiempo real?

Puede serlo en determinados contextos, pero no debe suponerse.

El Faster R-CNN original se presentó con resultados de velocidad importantes para su época.

Las implementaciones actuales deben medirse de manera independiente.

63. Ejemplo 19 — Benchmark de inferencia

import time
import torch
def benchmark(
    model,
    image,
    repetitions=10
):
    model.eval()
    device = next(
        model.parameters()
    ).device
    image = image.to(device)
    with torch.inference_mode():
        for _ in range(3):
            model([image])
        if device.type == "cuda":
            torch.cuda.synchronize()
        start = time.perf_counter()
        for _ in range(repetitions):
            model([image])
        if device.type == "cuda":
            torch.cuda.synchronize()
    return (
        time.perf_counter() - start
    ) / repetitions
sample = torch.rand(
    3, 640, 640
)
seconds = benchmark(
    model,
    sample
)
print(
    f"{seconds * 1000:.2f} ms por imagen"
)

¿Qué demuestra?

Podemos obtener una medición básica de latencia.

¿Es un benchmark definitivo?

No.

Para comparaciones rigurosas debemos registrar versiones, hardware, precisión numérica, calentamiento y variabilidad.

64. Faster R-CNN frente a SSD

SSD realiza detección mediante un enfoque de una etapa.

Faster R-CNN utiliza propuestas y clasificación posterior.

¿Qué puede favorecer SSD?

Diseños orientados a inferencia eficiente.

¿Qué puede favorecer Faster R-CNN?

Una arquitectura explícita de propuestas y refinamiento.

¿Cuál ofrece mayor precisión?

Depende de los modelos comparados y del benchmark.

65. Faster R-CNN frente a RetinaNet

RetinaNet es un detector One-Stage asociado con Focal Loss.

¿Qué diferencia existe?

RetinaNet aborda la detección sin una etapa RoI de propuestas seguida de clasificación.

Faster R-CNN utiliza RPN y RoI Heads.

¿Cuál es mejor?

No existe una conclusión universal.

66. Faster R-CNN frente a Mask R-CNN

Mask R-CNN extiende conceptualmente Faster R-CNN.

Faster R-CNN

Produce:

• Categoría.
• Caja.
• Puntuación.

Mask R-CNN

Añade:

• Máscara individual por objeto.

¿Una Faster R-CNN estándar produce máscaras?

No.

Para segmentación de instancias necesitamos una arquitectura o cabeza adicional.

67. ¿Puede Faster R-CNN utilizarse en comercio electrónico?

Sí.

Ejemplos

• Identificar productos en una fotografía.
• Localizar cajas y paquetes.
• Contar objetos visibles.
• Analizar estanterías.
• Reconocer categorías comerciales.

¿Puede reconocer automáticamente cualquier marca?

No.

Debe entrenarse o adaptarse a las categorías relevantes.

¿Puede identificar un SKU exacto?

Puede formar parte del sistema, pero a menudo se necesita reconocimiento más especializado.

68. Faster R-CNN en inspección industrial

Una empresa puede necesitar localizar componentes.

Ejemplo

Un sistema analiza una imagen de una línea de producción.

El detector identifica:

• Conectores.
• Tornillos.
• Herramientas.
• Piezas.

¿Qué podemos hacer con las detecciones?

• Contar componentes.
• Registrar posiciones.
• Comparar contra inventario esperado.
• Enviar resultados a otro sistema.

¿Detecta automáticamente defectos?

Solo si el sistema está diseñado y entrenado para detectarlos.

69. Faster R-CNN en imágenes médicas

Faster R-CNN puede investigarse como componente para localizar estructuras o regiones relevantes en imágenes biomédicas.

¿Es una herramienta clínica por sí misma?

No.

Su utilización médica requiere validaciones y controles adecuados al contexto.

¿Qué papel puede desempeñar?

La localización de regiones candidatas para análisis posterior.

70. Faster R-CNN en imágenes satelitales

Puede utilizarse para detectar objetos o estructuras visibles.

Ejemplos

• Vehículos.
• Embarcaciones.
• Edificios.
• Instalaciones.

¿Qué problema aparece?

El tamaño reducido de algunos objetos y las grandes dimensiones de las imágenes.

¿Qué estrategias pueden ayudar?

FPN, procesamiento por parches, mayor resolución y anotaciones específicas.

71. Faster R-CNN y AI Visibility

Una plataforma de AI Visibility puede utilizar detectores para estudiar activos visuales de marca.

Caso 1. Fotografías comerciales

Localizar productos dentro de imágenes.

Caso 2. Capturas de páginas web

Detectar componentes visuales específicos.

Caso 3. Análisis de catálogos

Identificar objetos presentes y sus posiciones.

Caso 4. Inspección de elementos de marca

Localizar elementos visuales reconocibles dentro de un conjunto de imágenes.

¿Qué aporta?

Información estructurada sobre categorías y ubicaciones.

¿Qué no aporta automáticamente?

No cambia las recomendaciones ni las citas generadas por asistentes externos.

72. ¿Faster R-CNN mejora Recommendation Rate?

No directamente.

Recommendation Rate mide recomendaciones observadas mediante un procedimiento determinado.

Faster R-CNN es una arquitectura de detección visual.

Su integración en una aplicación propia no modifica automáticamente las respuestas de asistentes externos.

73. ¿Faster R-CNN mejora Citation Coverage?

No directamente.

Citation Coverage se relaciona con las referencias observadas en respuestas generadas por asistentes.

Una Bounding Box no es una cita.

El detector puede mejorar herramientas visuales, pero no produce automáticamente nuevas referencias de marca.

74. Errores frecuentes con Faster R-CNN

Error 1. Confundir Fast R-CNN y Faster R-CNN

Faster R-CNN incorpora una RPN aprendible.

Error 2. Pensar que RPN clasifica categorías finales

La RPN predice Objectness y propuestas.

Error 3. Confundir Anchors con detecciones finales

Las Anchors son referencias iniciales.

Error 4. Suponer que las propuestas siempre corresponden a objetos

Pueden ser regiones de fondo.

Error 5. Confundir RoI Pooling y RoIAlign

Son operaciones relacionadas pero diferentes.

Error 6. Atribuir RoIAlign al Faster R-CNN original

RoIAlign se introdujo posteriormente con Mask R-CNN.

Error 7. Suponer que Faster R-CNN original utilizaba FPN

FPN es una incorporación posterior.

Error 8. Confundir Objectness y clasificación multiclase

Cumplen funciones distintas.

Error 9. Ignorar el formato XYXY

Puede generar cajas inválidas.

Error 10. Confundir coordenadas de imagen con coordenadas de Feature Map

Produce errores de alineación.

Error 11. Aplicar NMS con clases incorrectas

Puede eliminar detecciones legítimas.

Error 12. Confundir el IoU de entrenamiento con el IoU de evaluación

Pueden utilizar umbrales diferentes.

Error 13. Suponer que nueve Anchors por posición es obligatorio

Es una configuración histórica, no una regla general.

Error 14. No adaptar la cabeza al número de clases

Produce incompatibilidades.

Error 15. Olvidar la clase de fondo en Torchvision

Puede causar errores de clasificación.

Error 16. Suponer que una cabeza nueva ya reconoce las categorías comerciales

Necesita entrenamiento.

Error 17. Aplicar transformaciones geométricas sin actualizar las cajas

Destruye la alineación.

Error 18. Utilizar un Test Set durante selección de hiperparámetros

Introduce sesgo de evaluación.

Error 19. Medir solamente pérdida

No equivale a mAP.

Error 20. Confundir AP50 y COCO AP

Sus protocolos son diferentes.

Error 21. Ignorar objetos pequeños

Puede ocultar problemas importantes.

Error 22. No considerar oclusiones

Puede afectar la generalización.

Error 23. Comparar tiempos de inferencia en hardware diferente

No permite una conclusión válida.

Error 24. Suponer que Faster R-CNN siempre es más lento que YOLO

Depende de variantes y condiciones.

Error 25. Asociar Faster R-CNN directamente con mayor Citation Coverage

No existe una relación automática.

75. Buenas prácticas para Faster R-CNN

1. Comprender la evolución R-CNN.
2. Diferenciar claramente RPN y RoI Heads.
3. Documentar el backbone utilizado.
4. Verificar la configuración FPN.
5. Controlar tamaños y proporciones de Anchors.
6. Verificar coordenadas y formatos de cajas.
7. Utilizar correctamente RoIAlign.
8. Revisar los umbrales de entrenamiento.
9. Documentar NMS.
10. Utilizar datos etiquetados de calidad.
11. Separar entrenamiento, validación y prueba.
12. Evitar duplicados entre particiones.
13. Comenzar con un checkpoint preentrenado.
14. Adaptar la cabeza de clasificación.
15. Evaluar el rendimiento por categoría.
16. Medir mAP50 y mAP50-95.
17. Analizar errores de localización.
18. Evaluar objetos pequeños y ocluidos.
19. Ajustar umbrales mediante validación.
20. Medir latencia y memoria.
21. Comparar contra detectores One-Stage.
22. Registrar versiones y pesos.
23. Visualizar predicciones.
24. Evaluar con imágenes representativas.
25. Comprobar requisitos de despliegue y licencia.

Preguntas frecuentes sobre Faster R-CNN

¿Qué significa Faster R-CNN?

Faster Region-Based Convolutional Neural Network.

¿Qué es Faster R-CNN?

Es una arquitectura de detección de objetos de dos etapas con propuestas aprendibles.

¿Quién desarrolló Faster R-CNN?

Shaoqing Ren, Kaiming He, Ross Girshick y Jian Sun.

¿Cuándo se presentó?

En 2015.

¿Qué es R-CNN?

Region-Based Convolutional Neural Network.

¿Qué es Fast R-CNN?

Una arquitectura anterior que comparte características convolucionales, pero utiliza propuestas externas.

¿Qué innovación introdujo Faster R-CNN?

Una Region Proposal Network integrada.

¿Qué es la RPN?

Es una red que predice propuestas de objetos y Objectness.

¿La RPN identifica categorías finales?

No.

¿Qué es Objectness?

Es una puntuación relacionada con la presencia de un objeto en una región.

¿Qué es una Anchor Box?

Es una caja de referencia para producir propuestas.

¿Cuántos Anchors utiliza Faster R-CNN?

Depende de la configuración.

¿Qué es Box Regression?

Es el aprendizaje de ajustes de coordenadas.

¿Qué es Intersection over Union?

Es una medida de solapamiento entre cajas.

¿Qué es NMS?

Non-Maximum Suppression.

¿Faster R-CNN utiliza NMS?

Sí, en configuraciones habituales de propuestas y detecciones finales.

¿Qué es Region of Interest?

Es una región candidata de imagen.

¿Qué es RoI Pooling?

Es una operación para producir características de tamaño fijo de una región.

¿Qué es RoIAlign?

Es una operación de extracción de regiones con mejor tratamiento de alineación espacial.

¿RoIAlign apareció en el Faster R-CNN original?

No.

¿Qué es un Backbone?

Es una red que extrae características visuales.

¿Qué es ResNet-50?

Es una arquitectura residual frecuentemente utilizada como backbone.

¿Qué es Feature Pyramid Network?

Es una arquitectura que combina características a múltiples escalas.

¿FPN formaba parte del Faster R-CNN original?

No.

¿Qué es una RoI Head?

Es la etapa que clasifica y refina propuestas.

¿Qué diferencia existe entre Objectness y clasificación?

Objectness estima presencia de objetos; clasificación identifica categorías.

¿Qué es Smooth L1?

Es una función de pérdida utilizada para errores de regresión.

¿Qué es mAP?

Mean Average Precision.

¿Qué es AP50?

Es AP bajo un criterio de IoU 0,50.

¿Qué es AP75?

Es AP bajo un criterio de IoU 0,75.

¿Qué es COCO AP?

Es una métrica agregada sobre diferentes umbrales IoU y categorías.

¿Faster R-CNN siempre es más preciso que YOLO?

No.

¿Faster R-CNN siempre es más lento que YOLO?

No necesariamente.

¿Es una CNN?

Sí, en sus configuraciones convolucionales clásicas.

¿Se puede utilizar con PyTorch?

Sí.

¿Qué biblioteca proporciona implementaciones preentrenadas?

Torchvision.

¿Qué es fasterrcnn_resnet50_fpn_v2?

Es una implementación mejorada de Faster R-CNN con ResNet-50 y FPN.

¿Qué produce el modelo?

Cajas, etiquetas y puntuaciones.

¿Puede detectar varios objetos?

Sí.

¿Puede reconocer categorías personalizadas?

Sí, después de adaptación y entrenamiento.

¿Es necesario incluir fondo en num_classes?

Sí, en los constructores habituales de Faster R-CNN de Torchvision.

¿Se puede ejecutar en CPU?

Sí.

¿Es necesaria GPU?

No obligatoriamente.

¿Puede utilizarse Transfer Learning?

Sí.

¿Qué es Fine-Tuning?

Es adaptar pesos preentrenados a una nueva tarea.

¿Qué es Data Augmentation?

Es aplicar transformaciones de entrenamiento.

¿Deben actualizarse las Bounding Boxes durante aumentos geométricos?

Sí.

¿Qué es Small Object Detection?

Es la detección de objetos que ocupan pocas posiciones espaciales.

¿Qué es Occlusion?

Es la ocultación parcial de objetos.

¿Puede utilizarse Faster R-CNN en robótica?

Sí.

¿Puede utilizarse en inspección industrial?

Sí.

¿Puede analizar imágenes satelitales?

Sí.

¿Puede detectar productos comerciales?

Sí, si se entrena para sus categorías.

¿Puede producir máscaras individuales?

Una Faster R-CNN estándar no; Mask R-CNN añade esa capacidad.

¿Qué relación existe entre Faster R-CNN y Mask R-CNN?

Mask R-CNN amplía el detector de dos etapas con predicción de máscaras.

¿Faster R-CNN mejora Recommendation Rate?

No directamente.

¿Mejora Citation Coverage?

No directamente.

¿Por qué importa para AI Visibility?

Puede utilizarse para localizar productos y elementos visuales en herramientas de análisis de marca.

Conceptos relacionados

• Inteligencia Artificial.
• Aprendizaje Automático.
• Deep Learning.
• Visión por Computadora.
• Object Detection.
• Object Localization.
• Bounding Box.
• R-CNN.
• Fast R-CNN.
• Faster R-CNN.
• Region Proposal Network.
• RPN.
• Objectness.
• Anchor Boxes.
• Anchor Matching.
• Box Regression.
• Feature Maps.
• Backbone.
• ResNet-50.
• Feature Pyramid Network.
• RoI Pooling.
• RoIAlign.
• RoI Heads.
• Non-Maximum Suppression.
• Intersection over Union.
• Smooth L1 Loss.
• Cross-Entropy.
• Precision.
• Recall.
• Average Precision.
• Mean Average Precision.
• Transfer Learning.
• Fine-Tuning.
• YOLO.
• SSD.
• RetinaNet.
• Mask R-CNN.
• PyTorch.
• Torchvision.
• TorchMetrics.
• NumPy.
• AI Visibility.

Conclusión

La Arquitectura Faster R-CNN es uno de los desarrollos más importantes de la familia de detectores de objetos basados en regiones.

Su innovación fundamental consistió en integrar una Region Proposal Network que aprende a generar propuestas de objetos utilizando características convolucionales compartidas.

Este diseño permitió reducir la dependencia de algoritmos externos de propuestas y consolidó el enfoque de detección de dos etapas.

La RPN identifica regiones candidatas mediante Objectness y regresión de cajas.

Posteriormente, la RoI Head clasifica esas regiones y refina sus localizaciones.

Las implementaciones modernas pueden incorporar ResNet-50, Feature Pyramid Networks y RoIAlign para mejorar la extracción de características y el tratamiento multiescala.

Sin embargo, Faster R-CNN también presenta compromisos de memoria y latencia que deben evaluarse frente a detectores One-Stage como YOLO y SSD.

PyTorch y Torchvision proporcionan implementaciones preentrenadas y componentes para adaptar la arquitectura a categorías propias.

La evaluación debe incluir mAP, Precision, Recall y análisis por tamaño de objeto, además de pruebas de rendimiento en el hardware objetivo.

En aplicaciones empresariales, Faster R-CNN puede utilizarse para localizar productos, componentes industriales, vehículos y otros objetos visuales.

En AI Visibility puede servir como componente de herramientas de análisis de imágenes comerciales, pero no genera directamente nuevas recomendaciones ni citas de una marca.

La conclusión fundamental es que Faster R-CNN separa la generación de propuestas y la clasificación final mediante dos etapas que comparten características visuales. Esta arquitectura proporciona una base sólida para comprender la detección basada en regiones y sus extensiones modernas, como Mask R-CNN.