Experimentos de IA que puedes probar en tu navegador.
Ejemplo real: cada caso es un módulo electrónico, con x = voltaje e y = temperatura. Clase A (naranja) = defectuoso; Clase B (azul) = correcto.
Las coordenadas van de 0 a 1 porque son tus medidas reales reescaladas a ese rango. Por ejemplo, si el voltaje va de 0 a 5 V: 0 V → 0, 2,5 V → 0,5, 5 V → 1; y si la temperatura va de 0 a 100 °C: 0 °C → 0, 50 °C → 0,5, 100 °C → 1. Un módulo a 4 V y 80 °C se dibuja en (0,8 ; 0,8).
La red es como un dibujante que traza una línea entre los puntos naranjas y los azules. Las neuronas son los trazos que puede dibujar, y las capas son las veces que puede combinar esos trazos: con una sola capa hace un único trazo, y por eso la Espiral se le escapa aunque tenga muchas neuronas.
| Si el conjunto es… | Pon esto | Y verás |
|---|---|---|
| Dos grupos (fácil) | 1 capa · 2–3 neuronas | Una raya recta; acierta enseguida |
| Círculo | 1 capa · 4–6 neuronas | Una frontera con forma de anillo |
| XOR | 1 capa · 4–6 neuronas | Dos zonas separadas |
| Espiral | 2 capas · 8 neuronas · tanh · 0.1 | Una frontera que se enrosca; pasa del 90 % |
Si no llega, prueba en este orden:
¿Por qué no basta con poner más? Con demasiadas capas la red se aprende los ejemplos de memoria (hay pocos puntos y muchos ajustes que tocar, así que acierta en los que ya vio y falla con los nuevos), y además el aviso de error se va debilitando al atravesar tantas capas, como en el teléfono escacharrado. Hay un punto dulce: capacidad suficiente para hacer la curva, pero no tanta que no se pueda entrenar.
La zona de color del fondo es lo que la red decidiría en cada punto del lienzo, aunque ahí no haya ningún punto.
También puedes crear tus propios datos: elige Clase A o Clase B y clica en el lienzo para añadir puntos.
Qué aprende la red: es como colorear un mapa: pinta todo el fondo del recuadro. Las zonas que deja naranjas son las que considera «aquí van los puntos de Clase A»; las azules, las de Clase B.
Los puntos de color son ejemplos cuya respuesta ya conocemos, y le sirven a la red para ver dónde se equivoca y corregirse.
Si la forma es muy irregular (como la Espiral), hace falta más «capacidad»:
| Subir… | Qué consigue |
|---|---|
| Más neuronas | Cada neurona añade un trozo más a la curva → la frontera puede ser más retorcida. |
| Más capas | Combina esos trozos en formas más complejas (un anillo, una zona con partes separadas…). |
Regla práctica: si se queda corta, primero dale más tiempo (deja que siga entrenando: el acierto suele seguir subiendo). Si aún no llega, añade otra capa. Subir solo las neuronas no basta cuando hace falta combinar formas. Pero demasiada capacidad también es mala: la red se memoriza los puntos y luego falla con casos nuevos.
Referencia rápida: Dos grupos → pocas neuronas; Círculo y XOR → una capa oculta basta; Espiral → dos capas, 8 neuronas y tanh. Con una sola capa no llega: se queda en torno al 60 % aunque le pongas 16 neuronas.
Si es la primera vez que ves una red neuronal, no te preocupes: aquí está explicado en palabras sencillas. Piensa en la red como un conjunto de «reglas» que se van ajustando solas al ver ejemplos. Esas reglas son los pesos: los números que cambian durante el entrenamiento. Cada línea de la imagen es un peso que conecta una neurona con la siguiente.
Lienzo: clic para añadir un punto de la clase seleccionada; arrastra para moverlo y usa Mayús + clic para borrarlo. Al pasar el ratón por un punto verás sus coordenadas (x, y) —justo los dos valores que entran en la red— y cómo se activan las neuronas.
Red: pasa el ratón por una neurona y se marcarán en azul las que le envían señal, con el valor de cada peso escrito sobre su línea, además del detalle de las cuentas en el cuadro emergente. También puedes pasar el ratón por una línea concreta para ver su peso.
Cuándo termina: la red se detiene sola por dos motivos. (1) Acierta el 100% de los puntos. (2) La pérdida deja de bajar: si durante un rato (80 comprobaciones seguidas) no mejora, para. Puedes seguirlo en el contador «Sin mejorar», que sube hasta 80. No hay un valor concreto de pérdida al que haya que llegar; cuanto más baja mejor, pero lo normal es que se estanque. Si se para así, pulsa ▶ Entrenar para seguir un poco más.
Las casillas de la rejilla son las entradas. La red las combina en una capa oculta y termina dando cuatro probabilidades, una por forma; la más alta es su respuesta.
Tú no entrenas con tus dibujos: la red aprende de formas generadas al momento con desplazamiento y ruido aleatorios, y tus trazos sirven para probarla. Por eso acierta aunque dibujes torcido o descentrado: eso es justo lo que ha aprendido a tolerar.
Mantén pulsado con el botón izquierdo y arrastra para encender casillas; con el botón derecho las borras. El pincel es siempre de una sola casilla, así que puedes marcar puntos sueltos aunque la rejilla sea grande.
Muestra de lo que aprende: los últimos ejemplos generados.
De izquierda a derecha: la capa de entrada (una neurona por casilla del dibujo: 64, 256, 1.024 o 4.096 según la rejilla), las capas ocultas (una columna por capa: 1, 2 o 3) y las 4 de salida. El relleno de cada círculo indica cuánto se activa esa neurona con el dibujo actual. Al entrenar, los colores de las líneas irán cambiando: eso son los pesos corrigiéndose.
| Parámetros (pesos + sesgos) | — |
| Memoria en float32 | — |
| Memoria en int8 | — |
| Multiplicaciones por inferencia | — |
| Estimado en ESP32 · 240 MHz | — |
| Medido en tu navegador | — |
El tamaño y las multiplicaciones son cuentas reales sobre esta red. El tiempo del ESP32 es una estimación (supone unas 4 instrucciones por multiplicación); el del navegador sí está medido de verdad en tu equipo, una sola vez al cargar la red, así que no cambia mientras dibujas o entrenas.
Dibujo: mantén pulsado el botón izquierdo y arrastra para trazar líneas (se rellenan también las casillas por las que pasas deprisa, así que la línea sale continua); con el botón derecho borras. El botón 🎲 Ejemplo con ruido dibuja una forma al azar con imperfecciones, como si la hubiera trazado una persona. Cada vez que cambias el dibujo, la red lo clasifica al momento: mira las barras del panel Resultado, debajo.
Tamaño de la rejilla: empieza en 8 × 8. Al subir a 16 × 16, 32 × 32 o 64 × 64 la red recibe más casillas y el modelo crece: se ve en las cuentas del panel Resultado. El pincel sigue siendo de una casilla, así que en 64 × 64 cada punto es muy pequeño y dibujar con el ratón resulta incómodo: para eso es mejor el botón 🎲 Ejemplo con ruido.
Entrenamiento: la red no sabe nada al principio. Pulsa ▶ Entrenar y verás cómo las barras se van decantando por la clase correcta. Con ⏭ Paso avanzas de uno en uno, y con ↺ Reiniciar pesos la devuelves al estado inicial (pesos sorteados otra vez) para volver a empezar.
Cuándo termina: se detiene sola si acierta prácticamente todos los ejemplos nuevos, o si la pérdida lleva un rato sin bajar. No hay un valor fijo de pérdida al que llegar; sigue el contador «Sin mejorar», que sube hasta 25.
Acierto: se mide sobre ejemplos nuevos, generados aparte y nunca usados al entrenar. Menos neuronas ocultas suele bastar; si ves que falla mucho, prueba con más (y fíjate en que el modelo ocupa más memoria, como se ve abajo).
Las 25 casillas no se mezclan en una lista: entran conservando su posición. La casilla de arriba a la izquierda del dibujo es la neurona de arriba a la izquierda de la red. Así la red puede aprender dónde está cada rasgo (los ojos, la boca) y no solo cuántas casillas hay encendidas.
Es la misma idea que la demo 2, pero en tamaño de juguete: con 124 números que ajustar se entiende todo lo que pasa y la red entera cabe de un vistazo.
Y una diferencia importante con la demo 4 (el laberinto): esto es IA de percepción, así que un 95 % de acierto ya es un éxito —cada respuesta es independiente y equivocarse de vez en cuando no rompe nada—. Allí las decisiones van en cadena y un 95 % sería un desastre. En percepción se mide la media; en control, el peor caso.
Clic: enciende casillas · botón derecho: las borra.
Carga una de las 8 caras de ejemplo:
El acierto se mide con caras nuevas, con ruido, que la red nunca vio al entrenar: por eso es aprender y no memorizar.
Las 25 entradas son las casillas de tu dibujo; en medio, las 4 neuronas ocultas, y a la derecha las 4 salidas, una por cara. El relleno de cada círculo es cuánto se activa esa neurona con tu dibujo. Pasa el ratón por una oculta para ver solo sus conexiones.
Dibujo: clic o arrastra sobre la rejilla para encender casillas; con el botón derecho las borras. Con los botones de ejemplo cargas una de las 8 caras con las que se entrena. Cada vez que cambias el dibujo, la red lo clasifica al momento: míralo en las barras de Resultado.
Entrenamiento: al principio la red no sabe nada y sus respuestas son azar. Pulsa ▶ Entrenar y verás cómo las barras se van decantando por la cara correcta. Con ⏭ Paso avanzas de golpe, y con ↺ Reiniciar pesos la devuelves al estado inicial (pesos sorteados otra vez) para volver a empezar.
El gráfico: al pasar el ratón por una neurona oculta se resaltan solo sus conexiones, para ver qué casillas del dibujo la hacen sumar o restar.
Cuándo termina: se para sola cuando la pérdida ya es muy baja (acierta las 8 caras con mucha seguridad) o cuando lleva un rato sin bajar. Lo sigues en Pérdida y en el contador «Sin mejorar», que sube hasta 120. Si se para ahí y quieres insistir, pulsa otra vez ▶ Entrenar.
El profesor es un algoritmo de búsqueda: desde la meta va contando a cuántos pasos está cada casilla y marca como correcta la dirección que se acerca. Con eso se fabrica la tabla de respuestas con la que se entrena la red.
Esto se llama aprendizaje por imitación y es la base de muchas máquinas que conducen o navegan: no se les enseña «el bien», se les enseña lo que haría un experto.
¿Por qué mira así? Con saber solo «hay muro o no lo hay» a su lado, la red tendría que aprenderse el laberinto casilla a casilla, y a partir de cierto tamaño eso se le atraganta. Sabiendo a qué distancia está el muro en cada dirección ve la forma del pasillo, que es la información que de verdad hace falta para decidir. Es la dotación típica de un robot que navega: una brújula hacia la meta y cuatro sensores de distancia. Nada de esto necesita una cámara.
Y aquí está la lección: en un laberinto (o en un robot), un solo giro equivocado manda al agente a dar vueltas para siempre. Por eso no basta un 99 %: hay que llegar al 100 % de las decisiones.
Y no todos los problemas son iguales. Esto es IA de control. Compáralo con la demo 3: allí cada respuesta es independiente y fallar una de cada veinte no estropea nada, por eso un 95 % es un éxito. Aquí las decisiones van en cadena: en un trayecto de 20 decisiones, con un 95 % por decisión solo 0,9520 ≈ 36 % de los recorridos termina bien; con un 99 %, un 82 %; y solo el 100 % garantiza que no falle ninguno. En percepción se mide la media; en control, el peor caso.
💡 En qué se diferencia de la demo 3: allí un 95 % de acierto ya es un éxito, porque cada respuesta es independiente (eso es percepción); aquí un 95 % sería un desastre: las decisiones van en cadena y un solo error deja al agente dando vueltas (esto es control).
Pulsa en un pasillo para soltar al agente desde ahí.
A la izquierda, los 6 sensores: los dos primeros son su brújula —hacia dónde queda la meta, en horizontal y en vertical, de −1 a +1— y los cuatro siguientes son sus sensores de distancia: a cuántas casillas está el muro en cada dirección (0 = lo tiene pegado, 1 = pasillo largo hasta el muro). En medio, las neuronas ocultas, y a la derecha las 4 salidas: ↑ ↓ ← →. El relleno de cada círculo es cuánto se activa con la casilla en la que está el agente ahora mismo.
Entrenar: cada pulsación da vueltas a la tabla de respuestas del profesor hasta que la red las copia todas o hasta agotar 10 segundos, lo que llegue antes. Lo normal es que acabe en menos de un segundo: mira cómo sube Aciertos al decidir y se para en el 100 %. Si agota los 10 segundos sin llegar, pulsa otra vez: no empieza de cero, sigue donde lo dejó. Si aun así no sube, es que le faltan neuronas ocultas.
Simular: con ▶ Simular desde el inicio el agente sale del inicio, y si pulsas en un pasillo sale desde ahí. El rastro azul es el camino que va dejando hasta la meta.
Pistas del profesor: la casilla «Ver las pistas del profesor» pinta una flecha en cada pasillo con la dirección que el profesor considera correcta: es justo la respuesta que la red intenta copiar.
Prueba esto: pon el laberinto Extremo (25 × 25) y deja 8 neuronas ocultas. Verás que los aciertos se estancan en el 92 % por muchos segundos que entrenes: la red no tiene capacidad para tantas decisiones. Con 32 llega. Eso es el underfitting.
Y un aviso: en Extremo (25 × 25) la cosa está al límite — con 16 neuronas ocultas, de cada cuatro laberintos alguno se queda clavado en el 99,7 % (una casilla de 286) y no hay tiempo que lo arregle. Si te pasa, sube a 32 o pulsa 🎲 Otro laberinto: no está roto, es que has llegado al borde.
Los cuatro experimentos de arriba son la parte que sí podemos enseñar: modelos ligeros que corren enteros en tu navegador, sin servidor, y que caben en un chip como el ESP32. En paralelo mantenemos otras líneas de trabajo que, por estar en fase de pruebas o por acuerdo con el cliente, no se publican.
Trabajamos con dos enfoques. Primero, tratamiento de imagen por código: recortes, contraste, umbrales, medición. Es determinista, rápido y no depende de ningún servicio externo. Solo lo que no se resuelve así pasa a un modelo de IA, en local o por API. Actualmente estamos implementando esta combinación en varios casos reales sobre el terreno.
Usamos estas técnicas también hacia dentro: síntesis de documentación técnica, generación de código y prototipado rápido de firmware. Menos tiempo en lo repetitivo, más en el problema.
Mucho de lo que diseñamos aquí no es público: resolvemos problemas a medida que forman parte del know-how exclusivo de quien nos contrata. No es que falte contenido por subir; es que el secreto industrial de cada proyecto siempre va por delante.
Evaluamos su viabilidad con una prueba de concepto rápida, bajo acuerdo de confidencialidad.
Próximamente iremos añadiendo más entradas al Laboratorio IA.
