The KISS

The KISS - Klimt-Inspired Self-organizing System - is a university project developed for the Deep Learning and Applied Artificial Intelligence course, taught by Prof. Emanuele Rodolà, during the first year of my Master’s degree in Applied Mathematics at Sapienza University of Rome.

The project asks whether a learned local rule can reconstruct and maintain a visually complex artwork. Instead of generating an image in one forward pass, a Neural Cellular Automaton repeatedly updates a grid of cells. Each cell sees only its immediate neighborhood, yet their shared dynamics produce a recognizable global image inspired by Gustav Klimt’s The Kiss.

From one cell to an image

The automaton operates on a 64 x 64 grid with 16 channels per cell. The first four channels represent premultiplied RGBA values; the other twelve act as hidden memory that cells use to communicate and coordinate.

The initial state contains no image. Every value is zero except for one central living cell, whose alpha and hidden channels are activated. From this minimal seed, the system must learn the entire growth process.

At every step, each cell:

1. perceives its current state and local horizontal and vertical gradients through identity and Sobel filters;
2. passes the resulting features through a shared 1 x 1 neural update network with a 128-unit hidden layer;
3. adds the predicted state change only when selected by a stochastic update mask;
4. remains active only when supported by the alpha-based living mask.

The default fire rate is 0.5, so only a random subset of cells updates at each iteration. This asynchronous behavior makes the learned dynamics less dependent on a perfectly synchronized grid.

The three-stage pipeline

The final system separates growth, refinement, and transformation into three specialized models:

single seed
    -> Model 1: Grow
    -> Model 2: Improve and Persist
    -> Model 3: Transition and Zoom

Model 1: Grow

The first model learns to reconstruct the full Klimt-inspired target from the seed. Training uses a pattern pool of 1024 intermediate states and batches of 8. Half of each batch is reset to the original seed while the remaining samples are drawn from the pool, so the same model must learn both initial growth and persistence.

Rollouts are sampled between 64 and 256 steps. The objective combines an intermediate loss and a final loss, weighted 0.2 and 0.8. RGB reconstruction receives more weight than alpha reconstruction (2.5 versus 0.5), while a gradient-matching detail term with weight 0.15 discourages overly smooth results.

This stage exposed the project’s central failure mode: a checkpoint can become good at maintaining already developed states while forgetting how to grow from the original seed. For this reason, seed rollouts were monitored separately and training stopped around the last checkpoint that retained reliable growth, near step 1200.

Model 2: Improve and Persist

The second stage fine-tunes the selected grow model for sharper texture and longer stability. A frozen copy of Model 1 acts as a teacher, producing input states after 64 to 256 steps. The student then evolves those states for 128 to 512 additional steps.

The refinement objective increases the RGB weight to 3.0, reduces alpha to 0.35, and raises the detail term to 0.20. Standard L2 regularization (1e-6) controls parameter size, while anchor regularization (1e-5) keeps the student close to the original grow model. Teacher-generated inputs avoid filling a self-managed pool with unstable states and help preserve the original morphogenetic behavior.

Model 3: Transition and Zoom

The third model is trained from scratch to transform the complete image state into a second target focused on the faces. Its initial pool is generated by Model 2 after 48 to 256 steps, and fresh Model 2 states can replace part of each batch during training. The transition automaton runs for 64 to 512 steps and uses RGB, alpha, detail, and L2 losses.

This makes the final output a state-to-state transformation rather than a separate image generator: the zoom model receives the living internal state of the previous automaton and reorganizes it toward the close-up target.

What the experiments showed

The strongest result is methodological. Reconstruction loss alone is not a sufficient measure of success for a self-organizing model. Lower pool loss can hide the loss of seed-growth ability, so visual seed rollouts and long-horizon behavior must be evaluated alongside the numerical objective.

The experiments also showed that:

• higher RGB weighting preserves the target’s chromatic structure;
• gradient-based detail loss reduces blur and improves local transitions;
• longer rollouts improve persistence but can encourage growth forgetting;
• teacher-generated states stabilize the improvement phase;
• a separate NCA can learn a meaningful transition between two living image states.

Browser simulation

The trained models are available through a static browser application. The original Keras .weights.h5 checkpoints are converted into compact JSON files containing the two 1 x 1 convolution kernels and their biases. The browser runtime reconstructs the update network with JavaScript typed arrays, performs Sobel perception and alpha-based life masking, and advances the automaton with requestAnimationFrame.

The interface provides:

• weak and improved growth checkpoints;
• play, pause, and restart controls;
• configurable steps per frame;
• fire-rate selection, including the training default of 0.5;
• a live step counter;
• the learned transition that zooms toward the faces.

Because the simulation is implemented as a static site, it runs entirely in the browser without a backend.

Reproducibility and development

The repository contains a Colab notebook for each training stage, target images, loss logs, intermediate pool visualizations, exported Keras checkpoints, the H5-to-JSON conversion utility, and the complete static web application.

AI-assisted tools supported bibliography discovery, code refactoring, experiment ideation, paper summarization, report editing, and development of the web interface. The experiments, code, results, and final claims were reviewed by the author.

References

1. Mordvintsev, A., Randazzo, E., Niklasson, E., and Levin, M. Growing Neural Cellular Automata. Distill, 5(2):e23, 2020. DOI: 10.23915/distill.00023.
2. Mordvintsev, A., Randazzo, E., Niklasson, E., Levin, M., and Greydanus, S. Differentiable Self-organizing Systems. Distill, 2020.
3. Niklasson, E., Mordvintsev, A., Randazzo, E., and Levin, M. Self-Organising Textures. Distill, 2021. DOI: 10.23915/distill.00027.003.
4. Magrini, M. The KISS: source code, training notebooks, checkpoints, and project report. GitHub, 2026.

The KISS, acronimo di Klimt-Inspired Self-organizing System, è un progetto universitario sviluppato per il corso di Deep Learning and Applied Artificial Intelligence, tenuto dal Prof. Emanuele Rodolà, durante il primo anno della mia laurea magistrale in Matematica Applicata presso Sapienza Università di Roma.

Il progetto si chiede se una regola locale appresa possa ricostruire e mantenere un’opera visivamente complessa. Invece di generare un’immagine in un singolo passaggio, un automa cellulare neurale aggiorna ripetutamente una griglia di cellule. Ogni cellula vede soltanto il proprio vicinato immediato, ma le dinamiche condivise producono un’immagine globale riconoscibile, ispirata a Il bacio di Gustav Klimt.

Da una cellula a un’immagine

L’automa opera su una griglia 64 x 64 con 16 canali per cellula. I primi quattro canali rappresentano valori RGBA premoltiplicati; gli altri dodici funzionano come memoria nascosta che le cellule usano per comunicare e coordinarsi.

Lo stato iniziale non contiene alcuna immagine. Tutti i valori sono pari a zero, tranne quelli di una singola cellula vivente centrale, i cui canali alfa e nascosti vengono attivati. A partire da questo seme minimo, il sistema deve apprendere l’intero processo di crescita.

A ogni passaggio, ciascuna cellula:

1. percepisce il proprio stato corrente e i gradienti locali orizzontali e verticali mediante filtri identità e Sobel;
2. invia le caratteristiche risultanti a una rete neurale di aggiornamento condivisa 1 x 1, con uno strato nascosto da 128 unità;
3. aggiunge la variazione di stato prevista soltanto quando viene selezionata da una maschera di aggiornamento stocastica;
4. rimane attiva soltanto quando è supportata dalla maschera di vita basata sul canale alfa.

Il fire rate predefinito è 0.5, quindi a ogni iterazione si aggiorna soltanto un sottoinsieme casuale delle cellule. Questo comportamento asincrono rende le dinamiche apprese meno dipendenti da una griglia perfettamente sincronizzata.

La pipeline in tre fasi

Il sistema finale separa crescita, rifinitura e trasformazione in tre modelli specializzati:

singolo seme
    -> Modello 1: Crescita
    -> Modello 2: Miglioramento e persistenza
    -> Modello 3: Transizione e zoom

Modello 1: Crescita

Il primo modello impara a ricostruire dal seme l’intero obiettivo ispirato a Klimt. L’addestramento utilizza un pool di 1024 stati intermedi e batch da 8. Metà di ogni batch viene riportata al seme originale, mentre i campioni rimanenti sono estratti dal pool, così lo stesso modello deve apprendere sia la crescita iniziale sia la persistenza.

I rollout vengono campionati tra 64 e 256 passaggi. L’obiettivo combina una loss intermedia e una finale, con pesi rispettivamente 0.2 e 0.8. La ricostruzione RGB riceve più peso di quella alfa (2.5 contro 0.5), mentre un termine di dettaglio basato sulla corrispondenza dei gradienti, con peso 0.15, contrasta risultati troppo sfocati.

Questa fase ha mostrato la principale modalità di fallimento del progetto: un checkpoint può diventare efficace nel mantenere stati già sviluppati e allo stesso tempo dimenticare come crescere dal seme originale. Per questo motivo i rollout dal seme sono stati monitorati separatamente e l’addestramento è stato interrotto vicino all’ultimo checkpoint capace di conservare una crescita affidabile, intorno al passaggio 1200.

Modello 2: Miglioramento e persistenza

La seconda fase esegue il fine-tuning del modello di crescita selezionato per ottenere texture più definite e maggiore stabilità nel tempo. Una copia congelata del Modello 1 agisce da teacher e produce stati di input dopo un numero di passaggi compreso tra 64 e 256. Lo student evolve poi questi stati per altri 128 fino a 512 passaggi.

L’obiettivo di rifinitura aumenta il peso RGB a 3.0, riduce quello alfa a 0.35 e porta il termine di dettaglio a 0.20. La regolarizzazione L2 standard (1e-6) controlla la dimensione dei parametri, mentre la regolarizzazione anchor (1e-5) mantiene lo student vicino al modello di crescita originale. Gli input generati dal teacher evitano di riempire un pool autogestito con stati instabili e aiutano a preservare il comportamento morfogenetico originale.

Modello 3: Transizione e zoom

Il terzo modello viene addestrato da zero per trasformare lo stato completo dell’immagine in un secondo obiettivo incentrato sui volti. Il suo pool iniziale è generato dal Modello 2 dopo un numero di passaggi compreso tra 48 e 256; durante l’addestramento, nuovi stati del Modello 2 possono sostituire una parte del batch. L’automa di transizione opera da 64 a 512 passaggi e usa loss RGB, alfa, di dettaglio e L2.

In questo modo l’output finale è una trasformazione tra stati, non un generatore di immagini separato: il modello di zoom riceve lo stato interno vivente dell’automa precedente e lo riorganizza verso l’obiettivo ravvicinato.

Risultati degli esperimenti

Il risultato più importante riguarda il metodo. La sola loss di ricostruzione non è una misura sufficiente del successo di un modello auto-organizzante. Una loss più bassa sul pool può nascondere la perdita della capacità di crescita dal seme, quindi i rollout visivi dal seme e il comportamento su orizzonti lunghi devono essere valutati insieme all’obiettivo numerico.

Gli esperimenti hanno inoltre mostrato che:

• un peso RGB maggiore preserva la struttura cromatica dell’obiettivo;
• la loss di dettaglio basata sui gradienti riduce la sfocatura e migliora le transizioni locali;
• rollout più lunghi migliorano la persistenza, ma possono favorire la perdita della capacità di crescita;
• gli stati generati dal teacher stabilizzano la fase di miglioramento;
• un NCA separato può apprendere una transizione significativa tra due stati viventi dell’immagine.

Simulazione nel browser

I modelli addestrati sono disponibili tramite un’applicazione web statica. I checkpoint Keras originali .weights.h5 vengono convertiti in file JSON compatti contenenti i due kernel convoluzionali 1 x 1 e i relativi bias. Il runtime nel browser ricostruisce la rete di aggiornamento con typed array JavaScript, esegue la percezione Sobel e la maschera di vita basata sul canale alfa, quindi fa avanzare l’automa con requestAnimationFrame.

L’interfaccia offre:

• checkpoint di crescita debole e migliorata;
• controlli per avvio, pausa e riavvio;
• numero configurabile di passaggi per frame;
• selezione del fire rate, incluso il valore predefinito di addestramento 0.5;
• contatore dei passaggi in tempo reale;
• transizione appresa con zoom verso i volti.

Poiché la simulazione è implementata come sito statico, viene eseguita interamente nel browser senza backend.

Riproducibilità e sviluppo

Il repository contiene un notebook Colab per ogni fase di addestramento, le immagini obiettivo, i log delle loss, visualizzazioni intermedie del pool, i checkpoint Keras esportati, l’utilità di conversione da H5 a JSON e l’applicazione web statica completa.

Strumenti assistiti dall’intelligenza artificiale sono stati utilizzati per la ricerca bibliografica, il refactoring del codice, l’ideazione degli esperimenti, la sintesi degli articoli, la revisione della relazione e lo sviluppo dell’interfaccia web. Gli esperimenti, il codice, i risultati e le conclusioni finali sono stati verificati dall’autore.

Riferimenti

1. Mordvintsev, A., Randazzo, E., Niklasson, E., and Levin, M. Growing Neural Cellular Automata. Distill, 5(2):e23, 2020. DOI: 10.23915/distill.00023.
2. Mordvintsev, A., Randazzo, E., Niklasson, E., Levin, M., and Greydanus, S. Differentiable Self-organizing Systems. Distill, 2020.
3. Niklasson, E., Mordvintsev, A., Randazzo, E., and Levin, M. Self-Organising Textures. Distill, 2021. DOI: 10.23915/distill.00027.003.
4. Magrini, M. The KISS: source code, training notebooks, checkpoints, and project report. GitHub, 2026.