Cómo aceleramos en Ultralytics los modelos YOLO en tu chip favorito

En Ultralytics creamos modelos de visión artificial; básicamente, ¡enseñamos a los ordenadores a ver! Piensa en estos modelos como enormes recetas matemáticas. Están compuestos por operaciones (que llamamos capas) y un montón de números que llamamos pesos.

Nuestros modelos Ultralytics YOLO procesan las imágenes tal y como son en realidad: ¡matrices de números! Cada píxel no es más que valores de color, la cantidad de rojo, verde y azul (por tanto, RGB) de cada punto que compone la imagen. Llamamos «tensores» a estas matrices de números porque suena mucho mejor que «matrices multidimensionales», que a su vez suena mucho mejor que «números apilados sobre números, apilados sobre números».

Cuando introduces una imagen en nuestro modelo, emprende un viaje épico a través de la red. Imagina el tensor surfeando de capa en capa, transformándose, convolucionándose y sufriendo toda clase de manipulaciones matemáticas de la forma más hermosa posible. Es como una fiesta en la que los números se mezclan y socializan para extraer la esencia de lo que hace que un gato sea un gato o un coche sea un coche. A este proceso lo llamamos extracción de características.

¿Qué sale por el otro extremo? ¡Más números! Números con significado. En las tareas de detección, te indican exactamente dónde están las cosas en la imagen y qué es probable que sean. «¡Oye, hay un 95 % de probabilidades de que eso sea un perro en las coordenadas (x, y)!» A este proceso mágico lo llamamos inferencia.

Ahora bien, antes de que nuestros modelos puedan hacer su magia, tienen que ir a la escuela; hay que entrenarlos. La fase de entrenamiento es donde las cosas se ponen intensas.

Durante el entrenamiento, cada vez que presentamos una imagen a la red, no nos limitamos a obtener una respuesta. Hacemos dos cosas muy laboriosas. Primero, calculamos cuánto se ha equivocado la red (lo llamamos pérdida; básicamente, la distancia con respecto al centro de la diana). Segundo, y esto es lo importante, actualizamos todos y cada uno de los números (o pesos) de la red en función de esa pérdida. Imagínate que ajustas miles de pequeñas ruedas a la vez, y que cada ajuste se calcula para que la red sea más precisa cada vez.

En esencia, entrenamos la red corrigiéndola: cada error le enseña lo que NO debe hacer y ajustamos todos esos pesos para que, cuando vuelva a ver una imagen similar, se acerque más a la respuesta correcta. En definitiva, la red aprende al recibir pequeños empujones en la dirección adecuada, error tras error, hasta que empieza a acertar las predicciones.

¿De cuántos números estamos hablando? Bueno, nuestro pequeño y simpático YOLO11n tiene unos cuantos millones de parámetros. ¿Y YOLO11x? ¡Esa bestia tiene más de 50 millones de parámetros! Cuantos más parámetros, más detalles puedes codificar, como la diferencia entre dibujar con ceras y disponer de una paleta de artista completa.

Durante la inferencia, el número de parámetros es fundamental. Ejecutar una red de 3 millones de parámetros es como dar una vuelta a la manzana trotando. ¿Ejecutar una red de 50 millones de parámetros? Es más bien como correr una maratón mientras haces malabares con antorchas encendidas.

Entonces, ¿qué es EXACTAMENTE el cálculo? ¿Cómo se realizan todas estas operaciones con números? ¿Cómo podemos acelerarlas? Y ¿qué significa realmente «optimizar el cálculo»?

Cómo realizan los cálculos los chips#

Los cálculos se realizan en chips. Estos pequeños cuadrados de silicio son, básicamente, los castillos de arena más organizados del universo. Cada operación que ejecuta tu ordenador, cada suma, cada comparación, cada «si pasa esto, haz aquello», está grabada físicamente en el silicio. En zonas concretas del chip hay circuitos físicos dedicados a sumar números, y otros destinados a las operaciones lógicas. Es como una pequeña ciudad con barrios especializados en distintos tipos de matemáticas.

Esto probablemente te parezca extraño, incluso si eres informático. La razón es que llevamos los últimos 40 años construyendo capa tras capa de abstracción, como una lasaña tecnológica que ha crecido tanto que ya ni siquiera vemos la base. Hemos simplificado tanto las cosas que la mayoría de los programadores de hoy no tienen ni idea de cómo se realizan realmente los cálculos en el silicio. ¡No es culpa suya, sino que está hecho así!

Vamos a retirar estas capas. Echa un vistazo a este código Python facilísimo:

x = 1
if x == 1:
    y = x + 1

Creamos una variable x, le asignamos el valor 1 y, si x es igual a 1 (sorpresa: lo es), creamos y con el valor de x más 1. Tres líneas. Fácil.

Pero aquí es donde la cosa se pone interesante. Entre esas tres líneas aparentemente inocentes y el movimiento real de electrones por el silicio, se producen AL MENOS cuatro enormes capas de traducción (en realidad hay más, pero cuatro bastan para ilustrar el punto). Te guiaré por este viaje alucinante:

Capa 1: Python → Bytecode Primero, Python lee el código y lo compila en algo llamado bytecode, un lenguaje intermedio más fácil de procesar para los ordenadores, pero que te haría sangrar por los ojos si intentaras leerlo.

Capa 2: Bytecode → Código máquina El intérprete de Python (como CPython) toma ese bytecode y lo traduce a código máquina, las instrucciones que entiende realmente el procesador. Es aquí donde tu elegante «if x == 1» se convierte en algo como «CARGAR registro, COMPARAR registro, SALTAR si la marca cero está activada».

Capa 3: Código máquina → Microcódigo ¡Giro inesperado! Los procesadores modernos ni siquiera ejecutan directamente el código máquina. Lo descomponen en microcódigo, operaciones aún más pequeñas que pueden gestionar los componentes internos del chip. Una única instrucción «ADD» puede convertirse en varias microoperaciones.

Capa 4: Microcódigo → Electrónica física Por fin llegamos al silicio. Esas microoperaciones activan señales eléctricas reales que circulan por los transistores. Miles de millones de pequeños interruptores se encienden y se apagan, los electrones recorren caminos cuidadosamente diseñados y, de algún modo, como por arte de magia, 1 + 1 se convierte en 2.

Cada capa existe para ocultar la complejidad demencial de la capa inferior. Es como esas muñecas rusas, salvo que cada muñeca habla un idioma completamente distinto y la más pequeña está hecha literalmente de relámpagos atrapados en arena.

¿La ironía? Esas tres líneas de Python probablemente activen MILLONES de interruptores de transistores. Pero gracias a estas abstracciones, no tienes que pensar en nada de eso. Solo escribes «y = x + 1» y confías en que la magia ocurre en algún lugar de las profundidades del silicio.

La arquitectura#

Todas y cada una de las operaciones se implementan físicamente en el silicio, y el lugar del chip donde se realizan depende por completo de la topología del chip. Es como planificar una ciudad, pero para electrones. El sumador está aquí, el multiplicador está allá y todos tienen que comunicarse de forma eficiente.

Hay cientos de chips distintos en el mercado, cada uno diseñado para una finalidad diferente. ¿Qué cambia entre ellos? La topología: cómo se colocan e implementan las operaciones en el espacio físico. A esto lo llamamos arquitectura, ¡y hay un montón de arquitecturas!

• x86 (Intel y AMD): el veterano de la informática de escritorio, complejo pero potente
• ARM: impulsa tu teléfono y, cada vez más, tu portátil; está diseñado para ofrecer eficiencia
• RISC-V: el rebelde de código abierto, que gana terreno por todas partes
• PowerPC - La bestia de IBM, que antes se usaba en consolas de videojuegos y sigue siendo habitual en sistemas integrados
• MIPS: el favorito del ámbito académico, sencillo y elegante
• SPARC: la contribución de Sun Microsystems (ahora Oracle) a la computación de alto rendimiento
• Arquitecturas de GPU (núcleos CUDA de NVIDIA, RDNA de AMD): monstruos del procesamiento paralelo

Cada arquitectura no solo distribuye sus transistores de forma distinta, sino que también habla un idioma diferente. Las abstracciones que usamos para enviar instrucciones a estas máquinas son completamente distintas. Es como tener que escribir indicaciones para alguien, pero según el coche que conduzca, quizá tengas que escribirlas en francés, mandarín o mediante danza interpretativa.

El latido del silicio#

El combustible de nuestros chips son los electrones: la electricidad que fluye hacia el chip y proporciona la energía necesaria para realizar los cálculos. Pero la energía por sí sola no basta. Para que un chip funcione de verdad y mueva datos por su intrincada topología, todo depende de un componente fundamental: el reloj. Es lo que hace que los electrones circulen por rutas concretas en momentos determinados. Sin él, solo tendrías silicio alimentado que no hace nada.

Imagina que intentas coordinar un espectáculo enorme en el que miles de millones de componentes tienen que moverse en perfecta sincronía. Sin ritmo, sería un caos. Eso es exactamente lo que hace el reloj por tu procesador. Es un cristal que vibra a una velocidad increíblemente constante y emite impulsos eléctricos miles de millones de veces por segundo.

Cuando oyes «procesador de 3,5 GHz», esos GHz (gigahercios) indican la velocidad del reloj: 3.500 millones de pulsos por segundo. Cada pulso se llama ciclo de reloj y es la unidad de tiempo fundamental en informática.

NO ocurre NADA entre ciclos de reloj. Todo el ordenador se queda congelado a la espera del siguiente pulso. Es como el juego del escondite inglés más extremo del universo. En cada «luz verde» (pulso del reloj):

• Los datos se mueven entre los componentes
• Se ejecutan los cálculos
• Se toman decisiones lógicas
• Se lee o se escribe en la memoria

Algunas operaciones duran un ciclo (una suma sencilla), mientras que otras requieren muchos ciclos (una división o recuperar datos de la RAM). Todo está coreografiado con precisión: miles de millones de componentes realizan sus operaciones específicas, todos sincronizados con ese ritmo implacable.

Puedes hacer overclock al procesador aumentando su frecuencia de reloj: todo funciona más rápido, pero también genera más calor y se vuelve menos estable. Si te pasas, el ordenador se bloquea porque los electrones, literalmente, no pueden seguir el ritmo.

Antiguamente, estas operaciones se implementaban con máquinas del tamaño de una habitación. Pero los componentes que realizan todos estos cálculos son sorprendentemente sencillos: solo son interruptores. Interruptores de encendido y apagado.

Conecta suficientes interruptores siguiendo el patrón adecuado y tendrás un sistema de cálculo. Toda la revolución digital se reduce a una sofisticada disposición de interruptores.

Esta simplicidad significa que, si tienes interruptores, cualesquiera que sean, puedes construir un ordenador. Se han construido ordenadores funcionales con tuberías y válvulas de agua, fichas de dominó, bloques LEGO, canicas e incluso con redstone en Minecraft.

Los principios no han cambiado desde la década de 1940. Simplemente hemos aprendido a fabricar interruptores extremadamente pequeños. Tu teléfono tiene más potencia de cálculo que todos los ordenadores que llevaron a los seres humanos a la Luna y cabe en el bolsillo porque averiguamos cómo fabricar interruptores a escala atómica.

Cuando ejecutamos redes neuronales con millones de parámetros, accionamos estos pequeños interruptores miles de millones de veces por segundo, todo perfectamente sincronizado con el latido del cristal. Cada actualización de pesos, cada multiplicación de matrices y cada función de activación siguen el ritmo del reloj.

¡No me extraña que entrenar modelos haga que tu ordenador suene como si intentara despegar!

Cómo hacer que las redes neuronales vayan a toda pastilla#

Vale, tenemos estos chips con miles de millones de interruptores que bailan al ritmo de un cristal y queremos ejecutar en ellos redes neuronales con millones de parámetros. Debería ser fácil, ¿no? ¡Basta con pasarle los números al chip y dejar que se ponga en marcha!

Ejecutar redes neuronales rápidamente es como intentar preparar una cena de cinco platos en una cocina donde el frigorífico está a tres manzanas, solo tienes una sartén y cada ingrediente pesa 250 kilos. Las matemáticas en sí no son el mayor problema; lo demás es lo que complica las cosas.

El desajuste entre arquitecturas#

La mayoría de los chips se diseñaron para ejecutar Microsoft Word, no redes neuronales. Tu CPU se creó pensando que se pasaría la vida ejecutando condicionales, bucles y, de vez en cuando, calculando tus impuestos (la única operación que hasta los superordenadores encuentran emocionalmente agotadora). Está optimizada para operaciones secuenciales: haz esto, luego aquello y después lo otro.

Pero las redes neuronales son completamente diferentes. Quieren hacerlo TODO A LA VEZ. Durante el entrenamiento, se actualizan millones de pesos en función de lo equivocadas que hayan sido las predicciones. Durante la inferencia (es decir, al usar el modelo entrenado), se procesan datos mediante millones de cálculos simultáneos. Imagina que tienes que multiplicar un millón de números por otro millón de números. Tu CPU, que es muy bienintencionada, quiere hacerlo uno por uno, como un contable muy rápido pero metódico.

Por eso las GPU se convirtieron en la columna vertebral de la informática para IA. Las GPU se diseñaron para los videojuegos, donde hay que calcular simultáneamente el color de millones de píxeles. Resulta que calcular el color de los píxeles y hacer operaciones matemáticas con redes neuronales se parecen mucho: ambas tareas consisten en realizar la misma operación en enormes cantidades de datos en paralelo.

Pero ni siquiera las GPU son perfectas para las redes neuronales. Por eso las empresas están construyendo chips de IA especializados (TPU, NPU y cualquier otra sigla que termine en PU). Estos chips se diseñan desde cero con una única misión: acelerar las redes neuronales. Son como contratar a un chef que solo sabe preparar un plato, pero lo cocina a una velocidad sobrehumana. Mientras tu CPU se esfuerza con las operaciones matriciales secuenciales y tu GPU las gestiona bastante bien en paralelo, estos chips especializados se comen las matrices para desayunar, comer y cenar.

El muro de la memoria (o por qué mover bits cuesta más que hacer cálculos)#

En el cálculo moderno con redes neuronales, dedicamos más tiempo y energía a MOVER datos que a REALIZAR cálculos con ellos.

Imagina que el chip de tu ordenador es un matemático brillante que trabaja a la velocidad del rayo, pero tiene todos los libros de consulta repartidos por distintos edificios de la ciudad. Puede resolver cualquier ecuación al instante, pero primero tiene que conseguir los números, y ese desplazamiento lleva una eternidad.

Tu chip puede multiplicar dos números en un ciclo de reloj (recuerda: uno de esos miles de millones de pulsos por segundo). ¡A la velocidad del rayo! Pero recuperar esos números de la memoria y llevarlos al chip puede tardar CIENTOS de ciclos. Es como si tu matemático pudiera resolver un problema en un segundo, pero necesitara cinco minutos para ir andando a la biblioteca y volver.

La razón es la distancia (y el espacio). La electricidad se mueve rápido, pero no a una velocidad infinita. Cuanto más tienen que desplazarse los datos por el chip, más tardan. Los diseñadores de ordenadores resolvieron este problema creando una jerarquía de memoria, como si hubiera varios lugares de almacenamiento a distintas distancias:

• Registros (integrados directamente en las unidades de cálculo): el escritorio de tu matemático. ¡Acceso instantáneo! Pero son diminutos: solo puedes guardar unos 32 números. Es como tener notas adhesivas justo delante.
• Caché L1 (a micrómetros de distancia): la estantería de la oficina. Se tarda entre 3 y 4 ciclos en recuperar algo. Aquí caben unos cuantos miles de números.
• Caché L2 (a milímetros de distancia): el archivador del pasillo. Tarda entre 10 y 15 ciclos y puede almacenar unos cuantos millones de números.
• Caché L3 (al otro lado del chip): el almacén de la planta baja. Tarda entre 30 y 50 ciclos y guarda decenas de millones de números.
• RAM (en un chip completamente distinto): el almacén al otro lado de la ciudad. Tarda entre 100 y 300 ciclos. Aquí es donde viven tus miles de millones de números.
• SSD/disco duro (conectado mediante cables): otra ciudad completamente distinta. Tarda millones de ciclos. Muchísimo almacenamiento, pero a velocidad glacial.

Las estructuras exactas varían: puede que el chip de tu teléfono no tenga caché L3, mientras que la CPU de un servidor podría tener una enorme. Sin embargo, el principio sigue siendo el mismo: la memoria más cercana es más rápida, pero más pequeña.

Aquí es donde las redes neuronales empiezan a sufrir. Imagina que tu modelo Ultralytics YOLO tiene 50 millones de parámetros (ChatGPT tiene miles de millones, por cierto). Son 50 millones de números que tienen que viajar desde la memoria hasta las unidades de cálculo y volver. Aunque cada número ocupe solo 4 bytes, son 200 megabytes de datos que tienen que moverse por el sistema.

Puede que el chip procese cada número en un solo ciclo, pero si tarda 100 ciclos en recuperarlo de la RAM, pasas el 99 % del tiempo esperando a que llegue. Es como tener un coche de Fórmula 1 en un atasco. Toda esa potencia de cálculo está ahí, esperando a que lleguen los datos.

Esta es la idea clave: este es EL cuello de botella de la informática moderna. Se llama cuello de botella de von Neumann. Es relativamente fácil hacer que los chips calculen más rápido. Acelerar la memoria es tropezar con límites físicos. Por eso casi TODAS las optimizaciones de rendimiento en IA se realizan a nivel de memoria. Cuando los ingenieros aceleran las redes neuronales, rara vez hacen que las operaciones matemáticas sean más rápidas; buscan formas ingeniosas de mover menos datos, almacenarlos mejor en la caché o acceder a ellos de forma más inteligente.

Los chips de IA modernos no se centran únicamente en la velocidad de cálculo; también se obsesionan con el ancho de banda de la memoria y las estrategias de movimiento de datos. Precargan datos, reutilizan valores que ya están en la caché y organizan los cálculos para reducir al mínimo los accesos a la memoria. En la carrera del hardware de IA, no ganan quienes tienen las calculadoras más rápidas, sino quienes han descubierto cómo mantenerlas abastecidas de datos. Todo depende de optimizar los patrones de acceso a la memoria.

Cada vez que mueves un poco de datos, consumes energía. No mucha, hablamos de picojulios, pero cuando mueves terabytes por segundo, la cifra aumenta RÁPIDO. De hecho, mover datos 1 mm a través de un chip consume más energía que realizar el cálculo en sí.

Por eso tu portátil suena como un motor a reacción cuando entrenas redes neuronales. No son los cálculos los que generan calor, sino el movimiento de datos. Cada actualización de parámetros, cada cálculo del gradiente y cada pasada hacia delante está calentando literalmente tu habitación.

Los aceleradores de IA modernos son, básicamente, ejercicios de termodinámica. ¿Cuánto cálculo podemos concentrar antes de que se funda el chip? ¿A qué velocidad podemos disipar el calor? Es como hacer overclocking, pero el reloj siempre está al máximo y solo intentamos que no se produzca un incendio.

¿La solución? Diseño consciente de la arquitectura#

Las redes neuronales más rápidas no son necesariamente las más inteligentes: son las que se diseñan teniendo en cuenta los chips. Estas redes:

• Mantienen los datos lo más cerca posible
• Reutilizan los cálculos de forma sistemática
• Se ajustan perfectamente a las capacidades del hardware
• Minimizan a toda costa el movimiento de memoria

Es como la diferencia entre una receta que dice «usa ingredientes de tu supermercado local» y otra que exige importar especias del Tíbet, queso de Francia y agua de la Antártida. Puede que ambas estén buenas, pero una es sin duda más práctica.

Y por eso conseguir que las redes neuronales vayan rápido es todo un arte. No basta con hacer bien los cálculos: tienes que entender el hardware, respetar la jerarquía de memoria y bailar a la perfección al ritmo de la arquitectura.

Te damos la bienvenida a un mundo donde la informática se encuentra con la física, la ingeniería y la pura magia. Donde mover un número cuesta más que calcularlo. Donde el paralelismo es rápido, pero la sincronización es letal. Donde tu mayor enemigo no es la complejidad, sino la distancia.

Cómo hacemos que YOLO sea más rápido#

Cuando entrenas un modelo YOLO, obtienes una red neuronal que funciona de maravilla en tu entorno de entrenamiento. Pero aquí está el quid de la cuestión: tu GPU para videojuegos, tu iPhone y ese diminuto chip de una cámara de seguridad hablan idiomas completamente distintos. Tienen diferentes puntos fuertes y débiles, y distintas formas de procesar los datos.

Piénsalo así: una GPU tiene miles de núcleos que pueden trabajar simultáneamente; está diseñada para el procesamiento en paralelo. Mientras tanto, un chip móvil puede tener circuitos especiales diseñados específicamente para operaciones de IA, pero solo es capaz de realizar ciertos tipos de cálculos. ¿Y ese dispositivo periférico de la cámara de tu timbre? Intenta ejecutar IA con un presupuesto energético menor que el de una bombilla LED.

En Ultralytics, admitimos más de una docena de formatos de exportación, porque cada uno está optimizado para un hardware distinto. No se trata de tener demasiadas opciones, sino de contar con la opción adecuada para TUS necesidades específicas.

Fusión de operaciones: hacer más con menos#

En el modelo YOLO original, muchas operaciones se realizan en secuencia. Por ejemplo, podemos hacer una convolución, normalizar los resultados y luego aplicar una función de activación. Son tres pasos distintos, cada uno con sus propias lecturas y escrituras en memoria.

Pero aquí está lo ingenioso: podemos combinar estas operaciones en un solo paso. Al exportar YOLO para su despliegue, fusionamos estas operaciones. En lugar de:

1. Calcular la convolución → Guardar en memoria
2. Cargar desde la memoria → Normalizar → Guardar en memoria
3. Cargar desde la memoria → Aplicar la activación → Guardar en memoria

Hacemos lo siguiente:

1. Calcular la convolución + normalización + activación → Guardar en memoria

En un modelo YOLO típico que procesa una imagen de 640×640, este sencillo truco elimina gigabytes de transferencias de memoria innecesarias. En un móvil, es la diferencia entre una detección fluida en tiempo real y unos retrasos frustrantes.

Usar números más pequeños: la magia de la cuantización#

YOLO no necesita números superprecisos para detectar objetos con exactitud. Durante el entrenamiento, usamos 32 bits para representar cada peso; es como usar una calculadora científica para medir los ingredientes de un sándwich. ¿Y para el despliegue? Con 8 bits basta.

Esto se llama cuantización y es una de nuestras técnicas de optimización más potentes. Al utilizar números más pequeños:

• El modelo reduce su tamaño un 75 % (de 200 MB a 50 MB en Ultralytics YOLO11x)
• Se ejecuta entre 2 y 4 veces más rápido en la mayoría de los dispositivos
• Consume mucha menos energía (la batería de tu móvil te lo agradecerá)

No todas las capas de YOLO son igual de sensibles a esta reducción. ¿Las primeras capas, que detectan bordes y formas básicos? Son robustas: podemos usar números de 8 bits sin problema. Las capas de detección finales, que determinan «¿es un gato o un perro?», necesitan algo más de precisión. Así que ajustamos la precisión capa por capa y usamos solo los bits necesarios para mantener la exactitud y maximizar la velocidad.

Elegir el mejor algoritmo#

Hay docenas de formas distintas de realizar la misma operación matemática. Una convolución sencilla (la operación básica de YOLO) se puede calcular con algoritmos completamente distintos; la mejor opción depende de tu hardware y del tamaño de la entrada.

Al exportar YOLO, nuestro marco de optimización prueba distintos algoritmos y elige el más rápido para tu caso concreto. Es como tener varias rutas para llegar al mismo destino y elegir una según el tráfico del momento. En una GPU, podemos usar un algoritmo que procesa muchos píxeles a la vez. En una CPU, podemos usar otro optimizado para el procesamiento secuencial. Las matemáticas son las mismas, pero la estrategia de ejecución es completamente distinta.

Memoria: el cuello de botella oculto#

¿Recuerdas que hablamos de la memoria como el verdadero cuello de botella de la informática moderna? Esto es especialmente cierto en YOLO. El modelo puede tener 50 millones de parámetros y, durante la inferencia, generar gigabytes de resultados intermedios. A menudo, mover todos estos datos es más lento que realizar los cálculos.

Usamos varios trucos para reducir al mínimo el movimiento de memoria:

Planificación inteligente: Organizamos las operaciones para que los datos se utilicen inmediatamente, mientras aún están en la memoria caché rápida. En la red piramidal de características de YOLO, esto reduce el tráfico de memoria un 40 %.

Procesamiento por bloques: En lugar de procesar una imagen entera de una vez, la dividimos en bloques más pequeños que caben en la memoria caché. Así, el procesador puede trabajar con memoria local rápida en vez de estar recuperando datos constantemente de la memoria principal, que es más lenta.

Reutilización de búferes: En lugar de reservar memoria nueva continuamente para los resultados intermedios, reutilizamos los mismos búferes de memoria. Es increíblemente eficiente: toda la red troncal de YOLO puede ejecutarse con un conjunto de búferes reutilizables.

Poda: menos es más#

Un dato sorprendente: los modelos YOLO suelen estar sobredimensionados. A menudo podemos eliminar canales de muchas capas sin apenas afectar a la precisión. No se trata solo de hacer el modelo más pequeño: también se acelera, porque hay literalmente menos cálculos que realizar.

El proceso es elegante: analizamos qué partes de la red contribuyen menos a los resultados finales de detección, las eliminamos y después ajustamos el modelo para compensarlo. En dispositivos que funcionan con batería, esta mejora de eficiencia puede traducirse en horas adicionales de funcionamiento.

Aceleración por hardware: aprovechar los puntos fuertes de cada chip#

Cada procesador destaca en tareas distintas, y las diferencias de rendimiento no se deben solo a la velocidad de reloj: reflejan diferencias arquitectónicas fundamentales. Las GPU tienen miles de núcleos que trabajan en paralelo, perfectos para las convoluciones de YOLO. Las NPU móviles cuentan con circuitos especializados diseñados específicamente para redes neuronales. Las CPU son versátiles y flexibles, pero no están especializadas.

La clave de la optimización está en adaptar las operaciones de YOLO a lo que mejor hace cada chip. A una GPU se le da genial realizar la misma operación en muchos datos simultáneamente. Una NPU móvil quizá solo admita ciertas operaciones, pero las ejecuta con una eficiencia increíble. Un Edge TPU solo funciona con enteros de 8 bits, pero alcanza una velocidad extraordinaria dentro de esa limitación.

La magia de la compilación#

Al exportar un modelo YOLO, ocurre algo extraordinario entre bastidores. No nos limitamos a convertir el formato del archivo: compilamos el modelo específicamente para tu hardware de destino. Es como la diferencia entre Google Translate y un hablante nativo. El proceso de compilación:

1. Analiza tu modelo para comprender su estructura y sus requisitos
2. Tiene en cuenta las capacidades de tu hardware: en qué destaca y qué le cuesta
3. Genera código optimizado que habla el idioma nativo de tu hardware

El compilador puede reorganizar las operaciones para aprovechar mejor la memoria caché del procesador, seleccionar instrucciones especializadas compatibles con tu chip o incluso usar aprendizaje automático para encontrar la mejor estrategia de optimización. Sí, usamos IA para optimizar IA: ¡el futuro ya está aquí!

Este paso de compilación puede multiplicar por 10 el rendimiento. El mismo modelo YOLO puede avanzar a duras penas con código genérico y volar con instrucciones bien optimizadas.

Despliegue en dispositivos periféricos en el mundo real#

Hablemos de lo que ocurre cuando YOLO se enfrenta al mundo real, concretamente al desafiante mundo de los dispositivos periféricos. Imagina una cámara de seguridad que necesita ejecutar YOLO las 24 horas del día, los 7 días de la semana, para detectar objetos. Se enfrenta a unas limitaciones extremas:

• Memoria: quizá solo 512 MB o 2 GB de RAM en total
• Consumo: a menudo, solo entre 2 y 5 vatios (menos que un cargador de móvil)
• Refrigeración: sin ventiladores, solo disipación pasiva del calor
• Fiabilidad: debe funcionar de forma continua sin bloquearse

La clave está en elegir las concesiones adecuadas. En dispositivos periféricos, solemos:

• Usar cuantización INT8 (menos precisión y mucho menos consumo)
• Procesar menos fotogramas cuando hay poca actividad
• Repartir el trabajo entre distintos procesadores para controlar el calor
• Mantener los modelos lo bastante pequeños como para que quepan por completo en la memoria rápida

El proceso de optimización#

En Ultralytics, seguimos un enfoque sistemático para optimizar. Primero, perfilamos el modelo para entender en qué se emplea realmente el tiempo. A menudo, los cuellos de botella no están donde cabría esperar. Puede que el 80 % del tiempo se consuma en solo unas pocas capas o que las transferencias de memoria dominen el tiempo de cálculo.

A continuación, aplicamos optimizaciones de forma iterativa:

1. Empieza por los principales cuellos de botella
2. Aplica una optimización cada vez
3. Mide tanto la mejora de velocidad como el impacto en la precisión
4. Conserva las optimizaciones que ofrezcan un buen equilibrio
5. Repite el proceso hasta alcanzar tus objetivos

El futuro: la computación heterogénea#

Los dispositivos modernos cada vez aprovechan mejor varios procesadores a la vez. Tu móvil no tiene un único procesador: tiene varios, cada uno especializado en tareas distintas:

• El sensor de la cámara tiene un procesador de señal de imagen (ISP) para el preprocesamiento
• La unidad de procesamiento neuronal (NPU) ejecuta la inferencia de YOLO
• La CPU se encarga de la lógica compleja y la coordinación
• La GPU muestra los resultados en pantalla

El futuro de la optimización de YOLO consiste en distribuir inteligentemente el modelo entre estos procesadores. Quizá la NPU se encargue de las convoluciones principales, la CPU realice la lógica de detección final y la GPU visualice los resultados. Cada procesador hace lo que mejor se le da y crea una cadena de procesamiento más eficiente de lo que podría conseguir cualquier procesador por sí solo.

Estamos desarrollando algoritmos de partición inteligentes que determinan automáticamente la mejor forma de distribuir YOLO entre los procesadores disponibles, teniendo en cuenta no solo sus capacidades, sino también el coste de mover datos entre ellos.

En resumen#

Optimizar modelos YOLO no consiste únicamente en convertir formatos de archivo; se trata de transformar la IA más avanzada en algo que funcione de verdad en el mundo real. Mediante técnicas como la cuantización (uso de números más pequeños), la poda (eliminación de partes innecesarias), la fusión de operaciones (combinación de pasos) y una gestión inteligente de la memoria, conseguimos grandes mejoras de rendimiento sin perder precisión.

¿Lo más destacable? No hay una optimización «mejor» para todos los casos. Un servidor en la nube con energía ilimitada necesita optimizaciones distintas a las de un dron con batería. Un móvil con un chip de IA dedicado requiere un tratamiento distinto al de una Raspberry Pi. Por eso Ultralytics ofrece tantas opciones de exportación: cada una está optimizada para situaciones diferentes.

Cada optimización de la que hemos hablado contribuye a un único objetivo: hacer que la visión artificial sea accesible en todas partes. Tanto si estás creando un timbre inteligente, una aplicación para drones o un enorme servicio en la nube, te ofrecemos las herramientas necesarias para que YOLO funcione dentro de tus limitaciones.

Cuando exportas un modelo YOLO con Ultralytics, no te limitas a guardar un archivo. Aprovechas años de investigación para hacer prácticas las redes neuronales. Transformas un modelo de IA de última generación en algo que puede ejecutarse en hardware real, con limitaciones reales y resolviendo problemas reales.

Eso es lo que hacemos en Ultralytics. Cerramos la brecha entre la investigación en IA y la implementación práctica. Hacemos que la visión artificial funcione en todas partes, porque el futuro de la IA no consiste solo en tener los mejores modelos, sino en hacer que esos modelos sean útiles en el mundo real.