Memories of Passersby (Mario Klingemann — Memories of Passersby I)

Math essence

centroids c_i ∈ R^D with velocities v_i; update v_i ← momentum·v_i + drift·N(0,I) + jump_mask·U; integrate c_i ← c_i + v_i; soft centring pull c_i ← c_i − ε·c_i; project via fixed 2×D matrix; render each centroid as a 5×5 Gaussian splat of its assigned palette colour.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/ml_artists/KlingemannMemorex/reference.py

"""KlingemannMemorex — Mario Klingemann "Memories of Passersby I" (2018) kernel.

Inspired by Mario Klingemann's *Memories of Passersby I* (Sotheby's,
2018, sold as the first AI artwork at a major auction house): a
machine that never stops generating portraits, never repeats itself,
and "observes itself" in a feedback loop.  Klingemann trained a GAN on
17th-19th-century portraits and let its latent space drift, with each
new face a degraded memory of the previous one.

We translate the *kernel* of that work to numpy: instead of real GAN
latents, we maintain a set of N cluster centroids in a 64-D
"latent-like" space.  Each centroid has momentum, drifts with Brownian
noise, and occasionally jumps (the "memory slips" / sudden context
switch).  Each step we pick a random centroid, project it through a
fixed 64→2 random projector, and stamp a faded Gaussian dot onto the
canvas at that location.  Centroids are coloured by cluster id along
a fixed palette — the result is a slowly-evolving swarm of coloured
"memory points" that gradually fills the canvas with a faint,
multi-coloured pointillism.

References:
- https://www.sothebys.com/en/articles/artificial-intelligence-and-the-art-of-mario-klingemann
- https://aiartists.org/mario-klingemann
- http://quasimondo.com/
"""
from __future__ import annotations

from typing import ClassVar

import numpy as np


class KlingemannMemorex:
    """Simulated memories — cluster centroids drifting in a 64-D latent space.

    Parameters
    ----------
    dim : int
        Square canvas side length (px).
    n_clusters : int
        Number of cluster centroids N in the synthetic latent space.
    latent_dim : int
        Dimensionality D of the synthetic latent space (default 64, in
        the spirit of small GANs).
    drift : float
        Per-step Brownian noise scale on each centroid.
    momentum : float
        How much of the previous velocity is retained (0..1).
    jump_prob : float
        Per-step probability that any centroid "jumps" — replaces its
        velocity with a large random vector (Klingemann's "memory
        slips" / sudden context changes).
    jump_scale : float
        Magnitude of the jump vector when a jump fires.
    palette : str
        ``"pastel"`` (cool/light), ``"klingemann"`` (his auction-piece
        warm-earthy palette), or ``"rainbow"``.
    """

    family: ClassVar[str] = "ml_artists"