Uma única rede
Uma única rede para a pintura e todo o tópico
Uma rede real, construída aqui e treinada aqui: as manchas da pintura, a profundidade que a tinta sugere e cada letra desta conversa, em um único espaço compartilhado. Nada foi pré-treinado.
A pintura, fragmento por fragmento
A rede analisa a pintura em pequenos fragmentos, cada um com sua própria luz, cor e posição, e aprende essas palavras. Os mesmos pesos leem as letras do fio.
- Passos treinados
- 0
- Erro de imagem
- —
- Erro de letra
- —
- Erro de profundidade
- —
- Fragmentos que encontram suas palavras
- —
- Fragmentos de tinta
- 0
- Palavras em seu espaço
- 0
- Letras aprendidas
- 0
- Caracteres conhecidos
- 0
As palavras que ela aprende são aquelas que a tinta pode ensinar: quão brilhante é um fragmento, qual a sua cor, onde ele está localizado. A tarefa de texto aprende a ordem das letras, não o significado. Nada aqui é pré-treinado; os gradientes são processados nesta aba.
Treinamento, ao vivo
Começa automaticamente ao abrir a página e aprende aqui mesmo, nesta aba. A cada cem passos, ele registra o que mediu.
Aguardando a rede ser construída…
O aplicativo completo, em Python e JAX
Esta página e o programa abaixo são uma única rede. O programa é a aplicação completa: uma janela GTK4, gradientes JAX, a pintura, a thread, a profundidade que ele prevê e o espaço compartilhado. Copie ou salve, então execute-o em sua própria máquina.
- Manchas de tinta
- —
- Palavras que ele aprende
- —
- Letras que ele lê
- —
- Arquivos para manter juntos
- net_gtk.py
O que a janela faz
- Treine por 300 ou 2.000 passos, ou pare na metade; o aprendizado roda em uma thread para que a janela permaneça ativa.
- Clique em qualquer patch da pintura e ele informará as palavras que possui para aquele patch.
- Pergunte com palavras — ouro quente, azul escuro — e ele iluminará os patches onde a pergunta cair.
- Digite algumas letras e ele listará as letras que espera a seguir, com porcentagens.
- Cole seu próprio texto e pressione 'Aprender isso em vez disso': novas letras ganham novas linhas na mesma tabela, nada do que ele já sabia é descartado.
- Dois desenhos abaixo da pintura: a profundidade que ele prevê e o espaço onde pontos são tinta e quadrados são palavras.
- Salve os pesos em net_weights.json e carregue-os novamente na próxima vez.
Como executá-lo
Uma pasta, um arquivo e uma pintura chamada painting.jpg, se você tiver uma. No Linux, nessa pasta:
-
Instale os pacotes Python
python3 -m pip install jax numpy pillow -
Instale o GTK4 e suas vinculações Python
sudo apt install python3-gi gir1.2-gtk-4.0 -
Abra a janela
python3 net_gtk.py
No Windows, o caminho mais curto é o MSYS2: pacman -S mingw-w64-x86_64-python-gobject mingw-w64-x86_64-gtk4, depois python -m pip install jax numpy pillow, depois python net_gtk.py no mesmo terminal MSYS2.
No macOS: brew install pygobject3 gtk4, depois python3 -m pip install jax numpy pillow, depois python3 net_gtk.py.
Sem display? python3 net_gtk.py --selftest treina no terminal e imprime os mesmos números.
Medido ao executar este arquivo em um terminal com JAX, nesta pintura e nesta thread: 400 passos → 67% dos patches encontram suas próprias palavras (erro de imagem 0,68), 2.000 passos → 95% (0,53), 5.000 passos → 97% (0,45). O erro de profundidade termina em 0,0003 e o erro de letra cai de 3,05 para 2,90.
Um navegador não pode executar Python, então esta aba mostra o arquivo em vez da janela — a mesma rede está rodando ao vivo acima. As palavras que ele aprende são aquelas que a pintura pode ensinar: esta pintura não contém azul, então uma pergunta sobre azul cai em manchas douradas. O cabeçalho de letras conhece a ordem das letras, não o significado.
Um compilador para o Python e JAX acima
A caixa contém a passagem direta (forward pass) da rede única. O compilador a lê, verifica e a grava duas vezes: Python para JAX e JavaScript que roda nesta aba. Uma árvore, dois back-ends.
- Tokens
- —
- Nós na árvore
- —
- Funções
- —
O que ele computa
A verificação compara esses números com o mesmo programa executado em numpy e JAX com os mesmos pesos iniciais — medidos antes deste cartão existir, não estimados.
O que a linguagem permite
- def nome(a, b): com um corpo indentado, nome = ..., e return ...
- Números, nomes, colchetes, menos unário e + - * / @ para produto de matrizes.
- .T para transposição, e as chamadas tanh, sqrt, exp, log, sum, mean, maximum.
- Qualquer outra coisa interrompe o compilador com a linha e a coluna em vez de tentar adivinhar.
Este é um compilador real para uma linguagem pequena, não um runtime de Python: sem loops, sem classes, sem imports. A passagem direta da rede única cabe dentro dele, e é por isso que o mesmo texto pode se tornar JAX na sua máquina e JavaScript nesta aba.
Olhos virtuais: ele vê apenas pixels
Um olho apontado para um monitor: ele recebe a imagem e nada mais — nem página, nem dados, nem rede. Apenas a partir desses pixels, ele encontra bordas, cantos e como cada ponto desliza conforme o olho se move lateralmente, e a partir disso reconstrói onde tudo está no espaço.
- Quadros vistos
- 0
- Cantos
- 0
- Rastreado
- 0
- Movimento mediano
- —
- Profundidade encontrada
- —
- Pontos no espaço
- 0
- Um quadro
- —
A profundidade é geometria real, mas apenas até o tamanho do passo do olho, e apenas onde a imagem tem textura — tinta plana não oferece onde se apoiar. Ver onde uma parede está não é saber que é uma parede, e nada aqui inventa um mundo: a sala acima são os pixels, medidos.
Sua ideia, e o que ela ainda precisaria
- Olhos no monitor são uma interface real: um modelo que lê a tela da mesma forma que uma pessoa não precisa de plugin para cada programa — tudo o que é visível já é entrada.
- A partir de dois quadros de um olho em movimento, obtém-se a geometria, que é exatamente com o que um modelo de mundo deve concordar; esta parte este cartão faz de verdade.
- Um mundo gerado em tempo real também precisa de um modelo que invente o que ninguém viu, mantenha a consistência enquanto você gira e execute em milissegundos — isso não está nesta aba, e uma página não pode treiná-lo.
- O limite honesto: este olho recupera onde as coisas estão, não o que elas significam. A velocidade de ver não é compreensão, e uma é muito mais fácil que a outra.
Imagem: digitalização de domínio público de A Última Ceia de Leonardo da Vinci, Wikimedia Commons.