Detectar y segmentar: dónde está cada cosa

A mide 4 × 4, así que su área es 16; las otras tres también.

1. La intersección es [4, 4, 6, 6], de 2 × 2 = 4. La unión es 16 + 16 − 4 = 28. IoU = 4 / 28 ≈ 0,143. Correr una caja la mitad de su lado en las dos direcciones deja muy poco IoU.
2. La intersección es [3, 2, 6, 6], de 3 × 4 = 12. La unión es 16 + 16 − 12 = 20. IoU = 12 / 20 = 0,6.
3. La intersección sería [6, 2, 6, 6]: ancho 0. Las cajas solo comparten un borde, así que el IoU es 0.

A = [2, 2, 6, 6]
for nombre, otra in [("B", [4, 4, 8, 8]), ("C", [3, 2, 7, 6]),
                     ("D", [6, 2, 10, 6])]:
    print(f"IoU(A, {nombre}) = {iou(A, otra):.3f}")

IoU(A, B) = 0.143
IoU(A, C) = 0.600
IoU(A, D) = 0.000

from torchvision.ops import box_convert

anotada_xywh = torch.tensor([[251., 536., 97., 93.]])
detectada = [254, 535, 344, 613]

mal = iou(anotada_xywh[0].tolist(), detectada)
anotada = box_convert(anotada_xywh, in_fmt="xywh", out_fmt="xyxy")
bien = iou(anotada[0].tolist(), detectada)
print("Anotación convertida:", anotada[0].tolist())
print(f"IoU sin convertir: {mal:.3f}")
print(f"IoU convirtiendo:  {bien:.3f}")

Anotación convertida: [251.0, 536.0, 348.0, 629.0]
IoU sin convertir: 0.000
IoU convirtiendo:  0.761

Sin convertir, la anotación se lee como una caja «al revés» (su x₂ = 97 queda a la izquierda de su x₁ = 251), y el IoU da 0: concluirías que el detector falló. Convirtiendo, el IoU es 0,761: un acierto claro (pasa con holgura el 0,5 de costumbre). El código no avisa nada en ninguno de los dos casos; por eso conviene dibujar las cajas sobre la foto antes de confiar en un número.

Los IoU que importan (todas las cajas tienen área 100):

• A y B se cruzan en [1, 1, 10, 10], de 9 × 9 = 81: IoU = 81 / (200 − 81) ≈ 0,68.
• A y D se cruzan en [0, 2, 10, 10], de 10 × 8 = 80: IoU = 80 / 120 ≈ 0,67.
• C y E se cruzan en [22, 1, 30, 10], de 8 × 9 = 72: IoU = 72 / 128 ≈ 0,56.
• A, B y D no tocan a C ni a E.

Con umbral 0,5. Se queda A (0,90) y borra B y D, que pasan de 0,5. Quedan C y E: se queda C y borra E (0,56). Resultado: A y C.

Con umbral 0,6. Se queda A y borra B y D, como antes. Se queda C, pero E (0,56) ya no pasa de 0,6 y sobrevive. Resultado: A, C y E. Si E es una segunda caja sobre el mismo objeto que C, ese objeto se contaría dos veces.

cinco = np.array([[0, 0, 10, 10], [1, 1, 11, 11], [20, 0, 30, 10],
                  [0, 2, 10, 12], [22, 1, 32, 11]], dtype=float)
puntajes5 = np.array([0.90, 0.80, 0.75, 0.60, 0.30])
letras = "ABCDE"
print(np.round(iou_matriz(cinco, cinco), 2))
for umbral in [0.5, 0.6]:
    quedan = nms(cinco, puntajes5, umbral)
    print(f"Umbral {umbral}:", [letras[i] for i in quedan])

[[1.   0.68 0.   0.67 0.  ]
 [0.68 1.   0.   0.68 0.  ]
 [0.   0.   1.   0.   0.56]
 [0.67 0.68 0.   1.   0.  ]
 [0.   0.   0.56 0.   1.  ]]
Umbral 0.5: ['A', 'C']
Umbral 0.6: ['A', 'C', 'E']

from torchvision.ops import batched_nms


def nms_por_clase(cajas, puntajes, clases, umbral_iou=0.5):
    quedan = []
    for clase in set(clases):
        # Los índices de las cajas de esta clase
        indices = np.array([i for i, c in enumerate(clases) if c == clase])
        for j in nms(cajas[indices], puntajes[indices], umbral_iou):
            quedan.append(int(indices[j]))
    return sorted(quedan, key=lambda i: -puntajes[i])


for nombre, (cajas, clases, puntajes) in [
        ("Faster R-CNN", (crudas, clases_crudas, puntajes_crudos)),
        ("DETR", resultados["DETR"])]:
    mias = nms_por_clase(cajas, puntajes, clases)
    codigos = torch.tensor([CLASES.index(c) for c in clases])
    suyas = batched_nms(torch.tensor(cajas), torch.tensor(puntajes),
                        codigos, 0.5).tolist()
    print(f"{nombre}: quedan {len(mias)}; ¿igual que torchvision?",
          mias == suyas)

Faster R-CNN: quedan 6; ¿igual que torchvision? True
DETR: quedan 36; ¿igual que torchvision? True

nms recibe solo las cajas de una clase, así que los índices que devuelve son posiciones dentro de indices; hay que traducirlos con indices[j] a posiciones de la lista completa. Ese es el error más común al escribir esta función.

1. Contar personas. Aquí los dos errores pesan parecido: una falsa alarma suma una persona de más y una persona perdida, una de menos. Conviene un umbral de confianza intermedio (alrededor de 0,5 o 0,7) y elegirlo comparando con conteos hechos a mano en algunos cuadros. El umbral de IoU de la NMS no debe ser bajo: en una plaza la gente camina en grupos, sus cajas se cruzan, y con un umbral bajo la NMS borraría personas de verdad. Además, para contar personas distintas hace falta seguimiento, no solo contar por cuadro.
2. Baches. Perder un bache es caro (un accidente, una rueda rota) y una falsa alarma cuesta poco si una persona revisa la foto antes de mandar a la cuadrilla. Conviene un umbral de confianza bajo (más exhaustividad) y una revisión humana. Hay un problema previo: COCO no tiene la clase «bache», así que ninguno de los detectores del tema lo encuentra. Habría que anotar fotos propias y ajustar un detector, como hiciste con los modelos preentrenados en el tema «Visión moderna».

todo_fondo = torch.zeros_like(y_val)
pred = predecir_mascaras(unet, x_val)
for nombre, p in [("Siempre fondo", todo_fondo), ("U-Net", pred)]:
    exactitud = (p == y_val).float().mean().item()
    fondo, circulo, cuadrado = iou_clases(p, y_val)
    print(f"{nombre}: exactitud {exactitud:.3f}, IoU fondo {fondo:.2f}, "
          f"círculo {circulo:.2f}, cuadrado {cuadrado:.2f}")

Siempre fondo: exactitud 0.896, IoU fondo 0.90, círculo 0.00, cuadrado 0.00
U-Net: exactitud 0.996, IoU fondo 1.00, círculo 0.94, cuadrado 0.94

Con la exactitud por píxel, el modelo que no ve nada saca 0,896, cerca del 0,996 de la U-Net. Con el IoU de las formas, saca 0: no encontró ningún círculo ni cuadrado. El IoU por clase (o el Dice) es el que alerta. Fíjate en que el IoU del fondo también es alto para los dos: por eso se mira cada clase, y no solo el promedio.

1. IoU = I / U, y Dice = 2I / (|A| + |B|) = 2I / (U + I). Dividiendo arriba y abajo por U: Dice = 2 (I/U) / (1 + I/U) = 2 · IoU / (1 + IoU).
2. Con el código:

iou_c = iou_clases(pred, y_val)[1]
print(f"IoU del círculo: {iou_c:.4f}")
print(f"2·IoU/(1 + IoU): {2 * iou_c / (1 + iou_c):.4f}")
print(f"Dice calculado:  {dice_clase(pred, y_val, 1):.4f}")

IoU del círculo: 0.9371
2·IoU/(1 + IoU): 0.9675
Dice calculado:  0.9675

3. No. La función 2x / (1 + x) crece siempre entre 0 y 1, así que si un modelo tiene mayor IoU que otro en una clase, también tiene mayor Dice. Las dos medidas ordenan igual a los modelos de una clase; solo cambia la escala (el Dice da números más altos). Al promediar varias clases o varias imágenes sí pueden ordenar distinto, porque el promedio de los Dice no es el Dice del promedio.

Sin torch.cat, cada doble_conv del decodificador recibe la mitad de canales.

class UNetSinSaltos(UNet):
    def __init__(self, clases=3):
        super().__init__(clases)
        self.dec2 = doble_conv(16, 16)
        self.dec1 = doble_conv(8, 8)

    def forward(self, x):
        c1 = self.cod1(x)
        c2 = self.cod2(self.bajar(c1))
        centro = self.centro(self.bajar(c2))
        d2 = self.dec2(self.subir2(centro))       # sin c2
        d1 = self.dec1(self.subir1(d2))           # sin c1
        return self.salida(d1)


torch.manual_seed(0)
sin_saltos = UNetSinSaltos().to(device)
optimizador = torch.optim.Adam(sin_saltos.parameters(), lr=3e-3)
for epoca in range(1, 9):
    sin_saltos.train()
    for x, y in cargador:
        x, y = x.to(device), y.to(device)
        optimizador.zero_grad()
        perdida = nn.CrossEntropyLoss()(sin_saltos(x), y)
        perdida.backward()
        optimizador.step()

for nombre, modelo in [("Con saltos", unet), ("Sin saltos", sin_saltos)]:
    _, circulo, cuadrado = iou_clases(predecir_mascaras(modelo, x_val),
                                      y_val)
    print(f"{nombre}: IoU círculo {circulo:.2f}, cuadrado {cuadrado:.2f}")

Con saltos: IoU círculo 0.94, cuadrado 0.94
Sin saltos: IoU círculo 0.90, cuadrado 0.92

Sin saltos, el IoU baja de 0,94 a 0,90 en los círculos y a 0,92 en los cuadrados. La diferencia es chica porque nuestras formas son simples y la red baja solo dos veces de resolución (hasta 12 × 12). Aun así, sin saltos el decodificador tiene que reconstruir el contorno exacto de cada forma a partir de ese mapa chico, y lo esperable es que los errores se junten en los bordes: compruébalo dibujando las predicciones de los dos modelos para la misma imagen. En imágenes reales, con bordes finos y más bajadas de resolución, los saltos hacen una diferencia mucho mayor.

Las funciones de torchvision.ops (box_iou, nms, batched_nms, box_convert) trabajan con tensores de PyTorch, no con arreglos de NumPy. El mensaje lo dice a su manera: buscó un método de los tensores (is_floating_point) en un numpy.ndarray. Se arregla convirtiendo con torch.tensor (o torch.from_numpy):

print(box_iou(torch.tensor(caja_a), torch.tensor(caja_b)))

tensor([[0.3333]], dtype=torch.float64)

Es el mismo 1/3 que calculaste en la teoría con iou.

Con el video de la autopista, Faster R-CNN ve entre 5 y 10 vehículos a la vez en cada segundo del video y DETR entre 24 y 30: los dos siguen el mismo tráfico, pero DETR ve unas cuatro veces más. Si miras el cuadro de la teoría, hay varias decenas de autos a la vista, la mayoría chicos y lejanos: Faster R-CNN a 320 píxeles se pierde casi todos. DETR tarda varias veces más por cuadro (recuerda los tiempos de la teoría), pero para contar es mucho mejor.

Con tu video los números serán otros. Si la calle está cerca y los autos se ven grandes, los dos detectores pueden coincidir bastante; si está lejos, pasará lo mismo que aquí. El conteo por segundo sigue sin ser «vehículos que pasaron»: para eso necesitas el seguimiento del paso 5.