Un seul réseau
Un seul réseau pour la peinture et l'ensemble du fil
Un véritable réseau, construit ici et entraîné ici : les patchs de la peinture, la profondeur suggérée par la peinture et chaque lettre de cette conversation, dans un espace partagé. Rien n'est pré-entraîné.
La peinture, zone par zone
Le réseau examine la peinture par petites zones, chacune ayant sa propre lumière, couleur et position, et apprend ces mots. Les mêmes poids lisent les lettres du fil.
- Étapes d'entraînement
- 0
- Erreur d'image
- —
- Erreur de lettre
- —
- Erreur de profondeur
- —
- Patchs ayant trouvé leurs mots
- —
- Patchs de peinture
- 0
- Mots dans son espace
- 0
- Lettres apprises
- 0
- Caractères connus
- 0
Les mots qu'il apprend sont ceux que la peinture peut enseigner : la luminosité d'une zone, sa couleur, son emplacement. Le travail sur le texte apprend l'ordre des lettres, pas le sens. Rien n'est pré-entraîné ici ; les gradients s'exécutent dans cet onglet.
Entraînement, en direct
Il démarre tout seul à l'ouverture de la page et apprend ici même, dans cet onglet. Toutes les cent étapes, il note ce qu'il a mesuré.
En attente de la construction du réseau…
L'application complète, en Python et JAX
Cette page et le programme ci-dessous forment un seul réseau. Le programme est l'application entière : une fenêtre GTK4, des gradients JAX, la peinture, le thread, la profondeur qu'il prédit et l'espace partagé. Copiez-le ou enregistrez-le, puis exécutez-le sur votre propre machine.
- Taches de peinture
- —
- Mots qu'il apprend
- —
- Lettres qu'il lit
- —
- Fichiers à garder ensemble
- net_gtk.py
Ce que fait la fenêtre
- Entraînez pendant 300 ou 2 000 étapes, ou arrêtez à mi-chemin ; l'apprentissage s'exécute dans un fil pour que la fenêtre reste active.
- Cliquez sur n'importe quel patch du tableau et il vous indiquera les mots qu'il associe à ce patch.
- Demandez-lui avec des mots — or chaud, bleu foncé — et il illuminera les patchs correspondant à la question.
- Donnez-lui quelques lettres et il listera les lettres qu'il attend ensuite, avec des pourcentages.
- Collez votre propre texte et appuyez sur « Apprendre ceci à la place » : les nouvelles lettres reçoivent de nouvelles lignes dans le même tableau, rien de ce qu'il savait n'est supprimé.
- Deux dessins sous le tableau : la profondeur qu'il prédit, et l'espace où les points sont de la peinture et les carrés sont des mots.
- Enregistrez ses poids dans net_weights.json et rechargez-les la prochaine fois.
Comment l'exécuter
Un dossier, un fichier, et une peinture appelée painting.jpg si vous en avez une. Sur Linux, dans ce dossier :
-
Installer les paquets Python
python3 -m pip install jax numpy pillow -
Installer GTK4 et ses liaisons Python
sudo apt install python3-gi gir1.2-gtk-4.0 -
Ouvrir la fenêtre
python3 net_gtk.py
Sur Windows, la méthode courte est MSYS2 : pacman -S mingw-w64-x86_64-python-gobject mingw-w64-x86_64-gtk4, puis python -m pip install jax numpy pillow, puis python net_gtk.py dans ce même terminal MSYS2.
Sur macOS : brew install pygobject3 gtk4, puis python3 -m pip install jax numpy pillow, puis python3 net_gtk.py.
Pas d'affichage ? python3 net_gtk.py --selftest s'entraîne dans le terminal et affiche les mêmes chiffres.
Mesuré en exécutant ce fichier dans un terminal avec JAX, sur ce tableau et ce fil : 400 étapes → 67 % des patchs trouvent leurs propres mots (erreur d'image 0,68), 2 000 étapes → 95 % (0,53), 5 000 étapes → 97 % (0,45). L'erreur de profondeur se termine à 0,0003 et l'erreur de lettre descend de 3,05 à 2,90.
Un navigateur ne peut pas exécuter Python, donc cet onglet affiche le fichier plutôt que la fenêtre — le même réseau s'exécute en direct ci-dessus. Les mots qu'il apprend sont ceux que la peinture peut enseigner : cette peinture ne contient pas de bleu, donc une question sur le bleu atterrit sur des taches dorées. L'en-tête des lettres connaît l'ordre des lettres, pas le sens.
Un compilateur pour le Python et JAX ci-dessus
La boîte contient la passe avant du réseau unique. Le compilateur la lit, la vérifie et l'écrit deux fois : en Python pour JAX, et en JavaScript qui s'exécute dans cet onglet. Un arbre, deux back-ends.
- Jetons
- —
- Nœuds dans l'arbre
- —
- Fonctions
- —
Ce qu'il calcule
La vérification compare ces chiffres avec le même programme exécuté dans numpy et JAX sur les mêmes poids initialisés — mesurés avant l'existence de cette carte, et non estimés.
Ce que le langage autorise
- def name(a, b) : avec un corps indenté, name = ..., et return ...
- Nombres, noms, crochets, moins unaire, et + - * / @ pour un produit matriciel.
- .T pour une transposée, et les appels tanh, sqrt, exp, log, sum, mean, maximum.
- Tout autre élément arrête le compilateur en indiquant la ligne et la colonne au lieu de deviner.
Ceci est un véritable compilateur pour un petit langage, pas un runtime Python : pas de boucles, pas de classes, pas d'imports. La passe avant du réseau unique tient dedans, c'est pourquoi le même texte peut devenir du JAX sur votre machine et du JavaScript dans cet onglet.
Yeux virtuels : il ne voit que des pixels
Un œil pointé vers un moniteur : il reçoit l'image et rien d'autre — pas de page, pas de données, pas de réseau. À partir de ces seuls pixels, il trouve les contours, les coins et la façon dont chaque point glisse lorsque l'œil se déplace latéralement, et à partir de là, il reconstruit la position de chaque élément dans l'espace.
- Images vues
- 0
- Coins
- 0
- Suivi
- 0
- Mouvement médian
- —
- Profondeur trouvée
- —
- Points dans l'espace
- 0
- Une image
- —
La profondeur est une géométrie réelle, mais seulement jusqu'à la taille du pas de l'œil, et seulement là où l'image a de la texture — une peinture plate ne donne aucun point d'appui. Voir où se trouve un mur n'est pas savoir que c'est un mur, et rien ici n'invente un monde : la pièce ci-dessus est constituée de pixels mesurés.
Votre idée, et ce qu'il lui manquerait encore
- Des yeux sur le moniteur constituent une véritable interface : un modèle qui lit l'écran comme le fait une personne n'a besoin d'aucun plugin pour chaque programme — tout ce qui est visible est déjà une entrée.
- À partir de deux images d'un œil en mouvement, on obtient une géométrie, ce avec quoi un modèle du monde doit être en accord ; c'est cette partie que cette carte réalise concrètement.
- Un monde généré en temps réel nécessite également un modèle qui invente ce que personne n'a vu, le maintient cohérent lorsque vous tournez, et s'exécute en quelques millisecondes — cela ne se trouve pas dans cet onglet, et une page ne peut pas l'entraîner.
- La limite honnête : cet œil récupère l'emplacement des choses, pas leur signification. La vitesse de la vision n'est pas la compréhension, et l'une est bien plus facile que l'autre.
Image : scan du domaine public de La Cène de Léonard de Vinci, Wikimedia Commons.