Una sola red
Una sola red para la pintura y todo el hilo
Una red real, construida aquí y entrenada aquí: los parches de la pintura, la profundidad que sugiere la pintura y cada letra de esta conversación, en un espacio compartido. Nada está preentrenado.
La pintura, fragmento por fragmento
La red observa la pintura en pequeños fragmentos, cada uno con su propia luz, color y ubicación, y aprende esas palabras. Los mismos pesos leen las letras del hilo.
- Pasos entrenados
- 0
- Error de imagen
- —
- Error de letra
- —
- Error de profundidad
- —
- Parches que encuentran sus palabras
- —
- Parches de pintura
- 0
- Palabras en su espacio
- 0
- Letras aprendidas
- 0
- Caracteres conocidos
- 0
Las palabras que aprende son las que la pintura puede enseñar: qué tan brillante es un fragmento, qué color tiene, dónde se ubica. La tarea de texto aprende el orden de las letras, no el significado. Nada aquí está preentrenado; los gradientes se ejecutan en esta pestaña.
Entrenamiento en vivo
Se inicia solo al abrir la página y aprende aquí mismo, en esta pestaña. Cada cien pasos anota lo que midió.
Esperando a que se construya la red…
La aplicación completa, en Python y JAX
Esta página y el programa a continuación son una sola red. El programa es la aplicación completa: una ventana GTK4, gradientes de JAX, la pintura, el hilo, la profundidad que predice y el espacio compartido. Cópialo o guárdalo, y luego ejecútalo en tu propia máquina.
- Parches de pintura
- —
- Palabras que aprende
- —
- Letras que lee
- —
- Archivos que deben mantenerse juntos
- net_gtk.py
Qué hace la ventana
- Entrena 300 o 2 000 pasos, o detente a la mitad; el aprendizaje se ejecuta en un hilo para que la ventana permanezca activa.
- Haz clic en cualquier parche de la pintura y te dirá las palabras que tiene para ese parche.
- Pregúntale con palabras —oro cálido, azul oscuro— y iluminará los parches donde caiga la pregunta.
- Dale algunas letras y enumerará las letras que espera a continuación, con porcentajes.
- Pega tu propio escrito y presiona "Aprender esto en su lugar": las letras nuevas obtienen filas frescas en la misma tabla, nada de lo que ya sabía se desecha.
- Dos dibujos debajo de la pintura: la profundidad que predice y el espacio donde los puntos son pintura y los cuadrados son palabras.
- Guarda sus pesos en net_weights.json y cárgalos nuevamente la próxima vez.
Cómo ejecutarlo
Una carpeta, un archivo y una pintura llamada painting.jpg si tienes una. En Linux, en esa carpeta:
-
Instalar paquetes de Python
python3 -m pip install jax numpy pillow -
Instalar GTK4 y sus vinculaciones de Python
sudo apt install python3-gi gir1.2-gtk-4.0 -
Abrir la ventana
python3 net_gtk.py
En Windows, la forma corta es MSYS2: pacman -S mingw-w64-x86_64-python-gobject mingw-w64-x86_64-gtk4, luego python -m pip install jax numpy pillow, y luego python net_gtk.py en esa misma terminal de MSYS2.
En macOS: brew install pygobject3 gtk4, luego python3 -m pip install jax numpy pillow, y luego python3 net_gtk.py.
¿Sin pantalla? python3 net_gtk.py --selftest entrena en la terminal e imprime los mismos números.
Medido ejecutando este archivo en una terminal con JAX, en esta pintura y este hilo: 400 pasos → 67 % de los parches encuentran sus propias palabras (error de imagen 0.68), 2 000 pasos → 95 % (0.53), 5 000 pasos → 97 % (0.45). El error de profundidad termina en 0.0003 y el error de letra cae de 3.05 a 2.90.
Un navegador no puede ejecutar Python, por lo que esta pestaña muestra el archivo en lugar de la ventana; la misma red se está ejecutando en vivo arriba. Las palabras que aprende son las que la pintura puede enseñar: esta pintura no tiene azul, por lo que una pregunta sobre el azul cae en parches dorados. El encabezado de letras conoce el orden de las letras, no el significado.
Un compilador para el Python y JAX de arriba
El cuadro contiene el paso forward de la red única. El compilador lo lee, lo verifica y lo escribe dos veces: Python para JAX y JavaScript que se ejecuta en esta pestaña. Un árbol, dos back ends.
- Tokens
- —
- Nodos en el árbol
- —
- Funciones
- —
Qué computa
La verificación compara estos números con el mismo programa ejecutado en numpy y JAX con los mismos pesos semilla; medidos antes de que existiera esta tarjeta, no estimados.
Lo que el lenguaje permite
- def nombre(a, b): con un cuerpo indentado, nombre = ..., y return ...
- Números, nombres, corchetes, signo menos unario, y + - * / @ para un producto de matrices.
- .T para una transpuesta, y las llamadas tanh, sqrt, exp, log, sum, mean, maximum.
- Cualquier otra cosa detiene el compilador indicando la línea y la columna en lugar de adivinar.
Este es un compilador real para un lenguaje pequeño, no un entorno de ejecución de Python: sin bucles, sin clases, sin importaciones. El paso forward de la red única cabe dentro, razón por la cual el mismo texto puede convertirse en JAX en tu máquina y en JavaScript en esta pestaña.
Ojos virtuales: solo ve píxeles
Un ojo apuntando a un monitor: obtiene la imagen y nada más; ni página, ni datos, ni red. Solo a partir de esos píxeles encuentra bordes, esquinas y cómo se desliza cada punto mientras el ojo se desplaza lateralmente, y a partir de eso reconstruye dónde se encuentra todo en el espacio.
- Fotogramas vistos
- 0
- Esquinas
- 0
- Rastreado
- 0
- Movimiento mediano
- —
- Profundidad encontrada
- —
- Puntos en el espacio
- 0
- Un fotograma
- —
La profundidad es geometría real, pero solo hasta el tamaño del paso del ojo, y solo donde la imagen tiene textura; la pintura plana no ofrece nada a lo que aferrarse. Ver dónde está una pared no es saber que es una pared, y nada aquí inventa un mundo: la habitación de arriba son los píxeles, medidos.
Tu idea y lo que aún necesitaría
- Los ojos en el monitor son una interfaz real: un modelo que lee la pantalla de la misma manera que una persona no necesita un complemento para cada programa; cualquier cosa visible ya es una entrada.
- A partir de dos fotogramas de un ojo en movimiento se obtiene la geometría, que es exactamente con lo que un modelo de mundo debe coincidir; esta tarjeta hace esa parte de verdad.
- Un mundo generado en tiempo real también necesita un modelo que invente lo que nadie vio, lo mantenga coherente mientras giras y se ejecute en milisegundos; eso no está en esta pestaña, y una página no puede entrenarlo.
- El límite honesto: este ojo recupera dónde están las cosas, no qué significan. La velocidad de ver no es comprensión, y una es mucho más fácil que la otra.
Imagen: escaneo de dominio público de La última cena de Leonardo da Vinci, Wikimedia Commons.