Visión Artificial en Control de Calidad: Casos Reales

Un operador humano detecta el 85 % de los defectos en el mejor de los casos. A las 4 horas de turno, baja al 70 %. A las 8 horas, no quieres saber el número. Mientras tanto, cada producto defectuoso que avanza en la línea multiplica su coste — y si llega al cliente, el daño ya no es solo económico.

La visión artificial en control de calidad industrial ya no es tecnología experimental. Está operativa en líneas reales de todos los sectores con tasas de detección superiores al 99.5 % y tiempos de inspección de milisegundos. Aquí tienes casos reales con datos de rendimiento, hardware utilizado y lecciones aprendidas — no teoría, sino implementaciones en planta.

Para una visión más amplia de cómo la IA transforma la calidad industrial, el artículo sobre Control de Calidad con IA y Visión Artificial cubre el marco general.

Los componentes que hacen que funcione (y el que más se subestima)

Un sistema de visión artificial no es “poner una cámara”. La iluminación, la óptica y el procesamiento son igual de críticos — y el que más impacto tiene es, paradójicamente, el que menos presupuesto recibe.

Cámara industrial

Las cámaras industriales se diferencian de las comerciales en varios aspectos clave:

• Sensores globales (global shutter): capturan toda la imagen en el mismo instante, sin distorsión por movimiento. Imprescindible para líneas en movimiento.
• Interfaces estandarizadas: GigE Vision (Ethernet a 1-10 Gbps), USB3 Vision, CoaXPress para alta velocidad.
• Formato compacto y robusto: carcasas IP65/67, resistentes a vibración y temperatura industrial.

Tipo de cámara	Uso típico	Resolución	Velocidad
Área (matrix)	Inspección de piezas discretas	2-20 MP	30-500 fps
Escaneo lineal	Materiales continuos (papel, textil, metal laminado)	2K-16K píxeles/línea	Hasta 100.000 líneas/s
3D (perfilometría láser)	Inspección de volumen, altura, deformación	Variable	2.000-20.000 perfiles/s
Termográfica (LWIR)	Detección de puntos calientes, soldaduras	320×240 a 640×480	30-60 fps

Fabricantes de referencia: Basler (excelente relación calidad/precio), Cognex (soluciones integradas llave en mano), Keyence (cámaras con procesador integrado), Teledyne FLIR (imagen térmica e industrial), IDS Imaging (flexibilidad y SDK robusto).

Iluminación

Este es el componente más infravalorado. Hemos visto inversiones de 50.000 € en cámaras y GPU arruinadas por una iluminación de 200 €. Una mala iluminación produce imágenes inconsistentes que ningún algoritmo — por sofisticado que sea — puede compensar.

Tipos de iluminación industrial:

• Retroiluminación (backlight): la pieza queda en silueta. Ideal para medir contornos, detectar agujeros y verificar dimensiones.
• Anillo (ring light): montada alrededor del objetivo. Iluminación uniforme para superficies planas.
• Domo: iluminación difusa desde todas las direcciones. Elimina sombras y reflejos en superficies brillantes.
• Rasante (darkfield): ángulo bajo respecto a la superficie. Resalta arañazos, grietas y defectos superficiales que serían invisibles con iluminación directa.
• Estructurada (patrón de franjas): para reconstrucción 3D de la superficie.

Procesamiento de imagen

El procesamiento puede ejecutarse en:

• PC industrial con GPU: la opción más flexible. Permite ejecutar modelos de deep learning (YOLO, EfficientDet, modelos personalizados).
• Smart camera (cámara con procesador integrado): Cognex In-Sight, Keyence CV-X. Procesamiento embebido, configuración por interfaz gráfica, sin PC externo.
• Edge AI: dispositivos como NVIDIA Jetson Orin, combinan GPU dedicada en factor de forma compacto.

Comunicación con PLC

El resultado de la inspección tiene que llegar al PLC en milisegundos para activar el rechazo. Sin esta integración, la cámara es un visor caro:

• E/S digitales: la opción más rápida y fiable. Un cable, una señal: OK o NOK.
• Profinet / EtherNet/IP: comunicación por bus de campo industrial, permite enviar datos adicionales (tipo de defecto, coordenadas, imagen).
• OPC UA: estándar abierto para comunicación M2M, utilizado cuando el sistema de visión debe compartir datos con MES o SCADA.

Caso 1: inspección de soldadura en automoción

El problema

Un fabricante de componentes de automoción (subchasis y brazos de suspensión) necesitaba inspeccionar cordones de soldadura MIG/MAG. La inspección manual detectaba defectos con un 78 % de efectividad, y un inspector solo revisaba 120 piezas por turno. Insuficiente.

Solución implementada

Componente	Especificación
Cámara	Basler ace 2 Pro, 5 MP, GigE Vision, global shutter
Óptica	Lente telecéntrica 0.5x para eliminar distorsión de perspectiva
Iluminación	LED rasante rojo (630 nm) + domo difusor para eliminar reflejos metálicos
Procesamiento	PC industrial con NVIDIA RTX A2000, Ubuntu 22.04
Modelo	YOLOv8 entrenado con 12.000 imágenes etiquetadas (6 clases de defecto)
Comunicación	Profinet al PLC Siemens S7-1500

Clases de defecto detectadas

El modelo se entrenó para clasificar seis tipos de defecto:

1. Porosidad: agujeros en la superficie del cordón
2. Salpicadura excesiva: gotas de metal adheridas fuera del cordón
3. Cordón irregular: variación excesiva de ancho o altura
4. Falta de fusión: zonas donde el cordón no ha fundido con el material base
5. Mordedura (undercut): surco en el borde del cordón
6. Cordón incompleto: el cordón no cubre toda la longitud especificada

Pipeline de procesamiento

import cv2
from ultralytics import YOLO
import numpy as np

# Cargar modelo entrenado
model = YOLO("soldadura_yolov8m_best.pt")

def inspeccionar_soldadura(imagen_path: str, conf_threshold: float = 0.75):
    """
    Inspecciona una imagen de cordón de soldadura.
    Retorna: (resultado: str, defectos: list, imagen_anotada: np.ndarray)
    """
    img = cv2.imread(imagen_path)

    # Preprocesamiento: ecualización de histograma en canal V (HSV)
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    hsv[:, :, 2] = cv2.equalizeHist(hsv[:, :, 2])
    img_eq = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)

    # Inferencia
    results = model.predict(img_eq, conf=conf_threshold, imgsz=1280)

    defectos = []
    for box in results[0].boxes:
        clase = model.names[int(box.cls)]
        confianza = float(box.conf)
        coords = box.xyxy[0].tolist()
        defectos.append({
            "tipo": clase,
            "confianza": round(confianza, 3),
            "bbox": [int(c) for c in coords]
        })

    resultado = "NOK" if defectos else "OK"
    img_anotada = results[0].plot()

    return resultado, defectos, img_anotada

# Ejemplo de uso
resultado, defectos, img = inspeccionar_soldadura("pieza_001.jpg")
print(f"Resultado: {resultado}")
for d in defectos:
    print(f"  - {d['tipo']}: {d['confianza']*100:.1f}% en {d['bbox']}")

Resultados

Métrica	Inspección manual	Visión artificial
Tasa de detección	78 %	99.6 %
Falsos positivos	2 %	0.3 %
Piezas inspeccionadas/turno	120	960 (una cada 30 s)
Tiempo por inspección	4 min	1.2 s
Coste anual inspección	85.000 € (2 inspectores)	12.000 € (mantenimiento + energía)

ROI en 8 meses con una inversión de 45.000 € (hardware + desarrollo + puesta en marcha). No está mal para pasar del 78 % al 99.6 % de detección.

Caso 2: envases de vidrio en embotelladora

El problema

Planta embotelladora, 600 botellas por minuto. Necesitaban inspeccionar el 100 % de los envases antes del llenado — grietas, burbujas, deformaciones del cuello, impurezas. Con muestreo manual del 5 %, los defectos pasaban y generaban roturas en la llenadora. Cada rotura: parada de limpieza, producto contaminado, horas perdidas.

Solución implementada

Componente	Especificación
Cámaras	4× Basler ace 2, 12 MP, GigE, dispuestas a 0°, 90°, 180° y 270°
Iluminación	Retroiluminación LED blanca + iluminación rasante UV para detectar impurezas fluorescentes
Trigger	Encoder de velocidad de la cinta + fotocélula de posición
Procesamiento	2× NVIDIA Jetson Orin NX (una por cada par de cámaras)
Modelo	EfficientDet-D3 fine-tuned, 4 clases de defecto
Comunicación	E/S digital al PLC Allen-Bradley CompactLogix, señal de rechazo por soplado neumático

Sincronización con la línea

A 600 botellas/minuto, cada botella pasa por el punto de inspección cada 100 ms. El sistema debe:

1. Detectar la botella (fotocélula)
2. Disparar las 4 cámaras simultáneamente (trigger por hardware)
3. Procesar las 4 imágenes
4. Enviar señal OK/NOK al PLC
5. Si NOK: el PLC activa el soplador neumático que expulsa la botella de la línea

Todo en menos de 80 ms (con 20 ms de margen para el actuador neumático).

# Configuración de trigger por hardware (pseudocódigo Basler pylon)
from pypylon import pylon

camera = pylon.InstantCamera(pylon.TlFactory.GetInstance().CreateFirstDevice())
camera.Open()

# Configurar trigger por hardware (línea 1 del conector GPIO)
camera.TriggerSelector.Value = "FrameStart"
camera.TriggerMode.Value = "On"
camera.TriggerSource.Value = "Line1"
camera.TriggerActivation.Value = "RisingEdge"

# Exposición fija para consistencia
camera.ExposureMode.Value = "Timed"
camera.ExposureTime.Value = 500  # 500 µs — suficiente con LED potentes

# Ganancia mínima para reducir ruido
camera.Gain.Value = 0.0

Resultados

Métrica	Antes (muestreo 5 %)	Después (100 % inspección)
Botellas defectuosas detectadas	40 % de las defectuosas	99.8 %
Roturas en llenadora por defecto de botella	12/semana	0.3/semana
Producto contaminado por vidrio roto	2-3 lotes/mes	0 en 12 meses
Reclamaciones de cliente	8/mes	0.5/mes

La eliminación de roturas en la llenadora supuso un ahorro adicional de 120.000 €/año. Un número que convence a cualquier director financiero.

Caso 3: medición dimensional en mecanizado CNC

El problema

Taller de mecanizado CNC de alta precisión, piezas para aeronáutica con tolerancias de ±0.02 mm. La inspección con micrómetro manual consumía el 25 % del tiempo productivo del turno. Un cuarto de la capacidad de la máquina, desperdiciado en medir.

Solución implementada

Componente	Especificación
Cámara	Basler ace 2, 20 MP, USB3 Vision
Óptica	Lente telecéntrica bi-lateral 1x (bilateral para medir sin error de paralaje)
Iluminación	Retroiluminación telecéntrica colimada (Opto Engineering LTCLHP)
Calibración	Patrón certificado de cuadrícula (NIST traceable)
Software	OpenCV + algoritmo de detección de bordes sub-pixel
Comunicación	OPC UA al sistema MES para registro de medidas

Algoritmo de medición sub-pixel

La resolución óptica del sistema (20 MP con óptica telecéntrica 1x en sensor de 1”) proporcionaba una resolución de ~2.4 µm/píxel. Pero las tolerancias exigían medir con precisión de ±5 µm, lo que requería detección de bordes con precisión sub-pixel:

import cv2
import numpy as np

def medir_diametro_subpixel(imagen: np.ndarray, roi: tuple) -> float:
    """
    Mide el diámetro de una pieza cilíndrica con precisión sub-pixel.
    ROI: (x, y, w, h) de la zona de medición.
    Retorna: diámetro en píxeles (convertir a mm con factor de calibración).
    """
    x, y, w, h = roi
    crop = imagen[y:y+h, x:x+w]

    # Convertir a escala de grises si es necesario
    if len(crop.shape) == 3:
        gray = cv2.cvtColor(crop, cv2.COLOR_BGR2GRAY)
    else:
        gray = crop

    # Detección de bordes con gradiente Sobel
    sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=5)

    # Para cada fila, encontrar los dos bordes (transiciones de luz a sombra)
    medidas = []
    for fila in range(gray.shape[0]):
        perfil = sobel_x[fila, :]

        # Borde izquierdo: máximo positivo del gradiente
        idx_izq = np.argmax(perfil[:len(perfil)//2])
        # Refinamiento sub-pixel por interpolación parabólica
        if 1 <= idx_izq <= len(perfil) - 2:
            a, b, c = perfil[idx_izq-1], perfil[idx_izq], perfil[idx_izq+1]
            delta = 0.5 * (a - c) / (a - 2*b + c) if (a - 2*b + c) != 0 else 0
            borde_izq = idx_izq + delta
        else:
            borde_izq = float(idx_izq)

        # Borde derecho: mínimo negativo del gradiente (segunda mitad)
        idx_der = len(perfil)//2 + np.argmin(perfil[len(perfil)//2:])
        if 1 <= idx_der <= len(perfil) - 2:
            a, b, c = perfil[idx_der-1], perfil[idx_der], perfil[idx_der+1]
            delta = 0.5 * (a - c) / (a - 2*b + c) if (a - 2*b + c) != 0 else 0
            borde_der = idx_der + delta
        else:
            borde_der = float(idx_der)

        medidas.append(borde_der - borde_izq)

    # Filtrar outliers (±2σ) y promediar
    medidas = np.array(medidas)
    media = np.mean(medidas)
    std = np.std(medidas)
    medidas_filtradas = medidas[np.abs(medidas - media) < 2 * std]

    return float(np.mean(medidas_filtradas))

# Factor de calibración: px_to_mm obtenido de patrón certificado
PX_TO_MM = 0.00241  # 2.41 µm/px

diametro_px = medir_diametro_subpixel(imagen, roi=(500, 200, 3000, 2000))
diametro_mm = diametro_px * PX_TO_MM
print(f"Diámetro medido: {diametro_mm:.4f} mm")

Resultados

Métrica	Inspección manual (micrómetro)	Visión artificial
Precisión de medida	±10 µm (operador dependiente)	±5 µm (repetible)
Tiempo por pieza	3 minutos	0.8 segundos
Piezas medidas/turno	150	100 % de producción (~2.000)
Registro de medidas	Manual en hoja Excel	Automático en MES vía OPC UA
Trazabilidad	Parcial	Completa (imagen + medida + fecha/hora)

Caso 4: clasificación de cítricos

El problema

Cooperativa agrícola, 15 toneladas/hora de naranjas y mandarinas. Clasificación por calibre mecánica (rodillos) y por color visual (operarios). El resultado predecible: clasificación inconsistente, reclamaciones de compradores y producto de primera calidad vendido como segunda.

Solución implementada

Componente	Especificación
Cámaras	6× cámaras de color (Basler ace 2, 5 MP) en túnel de inspección
Iluminación	LED difuso blanco 6500K en cúpula cerrada (elimina reflejos)
Procesamiento	NVIDIA Jetson AGX Orin
Modelo	ResNet-50 fine-tuned para clasificación de color (5 categorías) + algoritmo clásico para calibre
Actuador	Eyectores neumáticos por canal (12 canales de salida)

Categorías de clasificación

Por color (modelo de deep learning):

• Extra: color uniforme, sin manchas verdes
• Primera: color predominante naranja, hasta 10 % verde residual
• Segunda: hasta 30 % verde o manchas superficiales leves
• Industrial: defectos de piel, manchas oscuras, maduración excesiva
• Descarte: podrido, daño mecánico severo

Por calibre (algoritmo de visión clásica):

• Se mide el diámetro ecuatorial de cada pieza a partir de la silueta
• Clasificación según norma de comercialización UE (calibres 1-7)

import cv2
import numpy as np
from tensorflow.keras.models import load_model

# Modelo de clasificación de color
modelo_color = load_model("citricos_resnet50_color.h5")
categorias_color = ["Extra", "Primera", "Segunda", "Industrial", "Descarte"]

def clasificar_citrico(imagen: np.ndarray) -> dict:
    """
    Clasifica un cítrico por color y calibre.
    imagen: recorte BGR del fruto individual.
    """
    # --- CALIBRE (visión clásica) ---
    gray = cv2.cvtColor(imagen, cv2.COLOR_BGR2GRAY)
    _, binaria = cv2.threshold(gray, 40, 255, cv2.THRESH_BINARY)
    contornos, _ = cv2.findContours(binaria, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    if not contornos:
        return {"color": "Descarte", "calibre": 0, "diametro_mm": 0}

    contorno = max(contornos, key=cv2.contourArea)
    (cx, cy), radius = cv2.minEnclosingCircle(contorno)
    diametro_px = radius * 2
    diametro_mm = diametro_px * PX_TO_MM_CALIBRACION  # Factor de calibración del sistema

    # Asignar calibre según norma UE
    if diametro_mm >= 81:
        calibre = 1
    elif diametro_mm >= 73:
        calibre = 2
    elif diametro_mm >= 66:
        calibre = 3
    elif diametro_mm >= 60:
        calibre = 4
    elif diametro_mm >= 55:
        calibre = 5
    elif diametro_mm >= 50:
        calibre = 6
    else:
        calibre = 7

    # --- COLOR (deep learning) ---
    img_resized = cv2.resize(imagen, (224, 224))
    img_norm = img_resized.astype("float32") / 255.0
    img_batch = np.expand_dims(img_norm, axis=0)

    prediccion = modelo_color.predict(img_batch, verbose=0)
    idx_color = np.argmax(prediccion)
    color = categorias_color[idx_color]
    confianza = float(prediccion[0][idx_color])

    return {
        "color": color,
        "confianza_color": round(confianza, 3),
        "calibre": calibre,
        "diametro_mm": round(diametro_mm, 1)
    }

Resultados

Métrica	Clasificación manual/mecánica	Visión artificial
Precisión clasificación color	72 % (subjetivo)	96.3 %
Precisión calibre	±5 mm (mecánico)	±1.5 mm
Velocidad	8 t/h	15 t/h (sin cuello de botella)
Reclamaciones de compradores	15/mes	2/mes
Producto de 1ª vendido como 2ª	~8 %	< 1 %

Solo la recuperación de producto de primera calidad que antes se vendía como segunda supuso 180.000 €/año más de ingresos. Sin producir un solo kilo más.

Integración con PLC: donde el sistema se juega el éxito

El mejor modelo de deep learning del mundo es inútil si no puede decirle al PLC “rechaza esta pieza” en el momento exacto. La integración tiene que ser determinista y rápida.

Ejemplo de comunicación por E/S digital

La forma más simple y fiable: una salida digital del PC/smart camera conectada a una entrada del PLC.

PC Visión (salida digital) ──► PLC (entrada digital DI 0.0)
                                    │
                                    ▼
                              Temporización por encoder
                                    │
                                    ▼
                              Activar soplador de rechazo (DO 4.0)

El PLC necesita compensar la distancia entre el punto de inspección y el punto de rechazo. Esto se hace contando pulsos de encoder:

// Programa PLC (Structured Text - IEC 61131-3)
// Rechazo de pieza defectuosa con compensación de distancia

VAR
    vision_nok      : BOOL;          // Entrada del sistema de visión
    encoder_pulsos  : DINT;          // Pulsos del encoder de la cinta
    rechazo_activo  : BOOL;          // Salida al soplador neumático
    
    // Buffer circular de posiciones NOK
    buffer_nok      : ARRAY[0..63] OF DINT;
    idx_escritura   : INT := 0;
    idx_lectura     : INT := 0;
    
    PULSOS_COMPENSACION : DINT := 4500;  // Distancia inspección → rechazo
    VENTANA_RECHAZO     : DINT := 200;   // Tolerancia en pulsos
END_VAR

// Al detectar NOK, guardar posición de rechazo
IF vision_nok AND NOT vision_nok_prev THEN
    buffer_nok[idx_escritura] := encoder_pulsos + PULSOS_COMPENSACION;
    idx_escritura := (idx_escritura + 1) MOD 64;
END_IF

// Verificar si la pieza ha llegado al punto de rechazo
IF idx_lectura <> idx_escritura THEN
    IF ABS(encoder_pulsos - buffer_nok[idx_lectura]) < VENTANA_RECHAZO THEN
        rechazo_activo := TRUE;
        idx_lectura := (idx_lectura + 1) MOD 64;
    ELSE
        rechazo_activo := FALSE;
    END_IF
ELSE
    rechazo_activo := FALSE;
END_IF

vision_nok_prev := vision_nok;

Comunicación por Profinet/EtherNet/IP

Para enviar datos adicionales al PLC (tipo de defecto, coordenadas, imagen en miniatura), se usan buses de campo industriales. El intercambio típico:

Dato	Dirección	Tipo	Uso
Resultado (OK/NOK)	PC → PLC	BOOL	Activar/desactivar rechazo
Código de defecto	PC → PLC	INT	0=OK, 1=grieta, 2=mancha, etc.
Confianza (%)	PC → PLC	REAL	Para filtrar por umbral
Trigger recibido	PLC → PC	BOOL	Confirmación de sincronización
Número de pieza	PLC → PC	DINT	Para trazabilidad

¿Cuándo necesitas deep learning y cuándo no?

No todos los problemas de inspección necesitan una red neuronal. Usar deep learning donde basta OpenCV es sobredimensionar. Usar OpenCV donde hace falta deep learning es fracasar.

Cuándo usar visión clásica (OpenCV)

• Medición dimensional (bordes definidos, alto contraste)
• Presencia/ausencia de componentes (¿tiene el tornillo? ¿falta la etiqueta?)
• Verificación de color por histograma
• Conteo de objetos con formas regulares

Cuándo usar deep learning

• Defectos con apariencia variable (arañazos, manchas, porosidad)
• Texturas complejas (madera, tejido, alimentos)
• Clasificación por categorías subjetivas (grado de madurez, calidad visual)
• Cuando las reglas de inspección son difíciles de formalizar

Modelos recomendados para inspección industrial

Modelo	Ventaja	Limitación	Caso de uso ideal
YOLOv8/v9	Velocidad + precisión, fácil de entrenar	Requiere GPU	Detección de defectos con localización
EfficientDet	Buen equilibrio tamaño/precisión	Más lento que YOLO	Edge computing (Jetson)
ResNet/EfficientNet	Clasificación robusta	Solo clasifica, no localiza	Clasificación OK/NOK global
Anomaly Detection (PatchCore, PADIM)	No necesita imágenes de defectos para entrenar	Menos preciso en defectos sutiles	Cuando hay pocas muestras de defecto

Estas mismas técnicas se aplican a mantenimiento: la inspección visual de desgaste alimenta modelos de mantenimiento predictivo con IA y Python.

ROI: los números que convencen a dirección

Sin justificación económica no hay proyecto. Estos son los cuatro ejes donde la visión artificial genera retorno:

1. Reducción de costes de inspección manual

Ahorro anual = (inspectores × coste_anual) - coste_mantenimiento_sistema
Ejemplo: (2 × 42.000 €) - 12.000 € = 72.000 €/año

2. Reducción de producto defectuoso enviado al cliente

Ahorro = reclamaciones_evitadas × coste_medio_reclamación
Ejemplo: 80 reclamaciones/año × 1.500 €/reclamación = 120.000 €/año

3. Reducción de desperdicio interno

Ahorro = piezas_detectadas_a_tiempo × (coste_pieza_en_etapa_final - coste_pieza_en_etapa_actual)

Detectar un defecto en la primera operación de mecanizado cuesta céntimos. Detectarlo después de 5 operaciones, tratamiento térmico y acabado puede costar decenas de euros por pieza.

4. Datos para mejora de proceso

Este es el beneficio oculto y muchas veces el más valioso. Los sistemas de visión generan datos que revelan causas raíz: si el 80 % de las grietas aparecen en piezas del proveedor B, o en el turno de noche, o después de un cambio de herramienta, tienes información accionable para mejorar el proceso.

Estos datos se integran con gemelos digitales para simular cambios antes de implementarlos.

Los errores que hunden proyectos de visión artificial

1. Subestimar la iluminación

El error número uno, sin discusión. Cámara de 20 MP, GPU de 3.000 €, modelo entrenado durante semanas… y la iluminación es el fluorescente del techo. Gastar al menos el 30 % del presupuesto de hardware en iluminación no es una recomendación — es una necesidad.

2. Dataset insuficiente o sesgado

200 imágenes de defectos tomadas un martes producen un modelo que funciona los martes. Cuando cambia la iluminación, el lote de materia prima o la temperatura, falla. Mínimo real: 1.000-5.000 imágenes por clase, capturadas en condiciones variadas a lo largo de semanas.

3. No validar en producción real

99.5 % en el dataset de test suena genial. Hasta que lo pones en la línea y cae al 92 %. Valida siempre con la línea en marcha, al menos dos semanas, comparando con inspección manual en paralelo.

4. Ignorar la limpieza de la óptica

Las lentes en entornos industriales se ensucian. Polvo, grasa, vapor. Un programa de limpieza periódica y un sistema de detección de degradación de imagen (monitorización de la homogeneidad del fondo) son imprescindibles.

5. No guardar las imágenes de rechazo

Guarda siempre las imágenes de piezas rechazadas. Sirven para auditoría, mejora del modelo y resolver disputas con clientes o proveedores. Un disco duro de 4 TB cuesta 80 €; perder una disputa por no tener evidencia cuesta mucho más.

Lo que determina el éxito

Cuatro casos, cuatro sectores diferentes, el mismo patrón: detección superior al 99 %, inspección en milisegundos, ROI inferior a 18 meses. La tecnología funciona.

Pero la clave no está en el algoritmo más sofisticado ni en la cámara más cara. Está en la iluminación, en el dataset de entrenamiento, en la integración con el PLC y en la validación rigurosa en producción real. La implementación es lo que marca la diferencia entre un proyecto que transforma la calidad y uno que acumula polvo en un armario.