KEEP-fashion-mnist

KEEP — KEEP-fashion-mnist

KEEP (Keep what Endures under Environmental Perturbation) est une architecture de réseau de neurones développée à AMEFORGE .

Ce dépôt contient un modèle KEEP entraîné à classer des images de vêtements (Fashion-MNIST).

---

La primitive

KEEP repose sur une règle de calcul unique :

chaque nœud se prédit à partir de ses voisins, et seule l'erreur de prédiction est propagée vers le haut.

Formellement, pour un champ u sur un graphe de voisinage N(i) :

û_i = P({ u_j : j ∈ N(i) })          # prédiction depuis les voisins
e_i = u_i - sg(û_i)                    # erreur = surprise
g_i = σ(W_g·e_i + w_m·‖e_i‖)           # porte indexée sur l'amplitude
a_i = Up([ g_i ⊙ e_i ; û_i ])          # deux flux : surprise + rétention

Le voisinage est un paramètre. Voisins = instants passés → séquence. Voisins = pixels adjacents → image (le cas de ce modèle). Voisins = arêtes → graphe. Le cœur du calcul ne change pas d'un domaine à l'autre.

---

Propriétés

• Aucune attention — pas de matrice QKᵀ. Ce n'est pas un transformer.
• Aucun tokenizer — les pixels entrent directement, aucun vocabulaire prédéfini.
• Aucune convolution — opérateur local, mais par propagation d'erreur prédictive et non par filtrage convolutif.
• Objectif latent — la prédiction porte sur des représentations, pas sur des pixels.
• Coût sous-quadratique — O(N·k) où k est la taille du voisinage.

---

Résultat

Le modèle est petit : 48,874 paramètres, soit environ 0.20 Mo en FP32.

---

Utilisation

import torch
from keep_mnist import KEEP_MNIST      # définition de l'architecture (dans ce dépôt)

model = KEEP_MNIST()
model.load_state_dict(torch.load("keep_fashion.pt", map_location="cpu"))
model.eval()

# images : tenseur [B, 784], valeurs dans [0, 1]
logits, _ = model(images)
predictions = logits.argmax(-1)

Pour réentraîner depuis zéro :

python keep_mnist.py     # DATASET = "fashion" ou "mnist" en tête du fichier

---

Limites connues

Ces limites ont été mesurées et sont publiées telles quelles.

• Coût de calcul élevé. Les poids sont partagés entre toutes les positions, donc le modèle est compact mais effectue beaucoup plus d'opérations par image qu'un réseau dense équivalent. Moins de mémoire, plus de calcul.
• Pas d'apprentissage à partir de très peu d'exemples. Entraîner la représentation sans étiquettes puis classer avec 5 exemples par classe ne fonctionne pas bien : l'objectif de prédiction locale apprend la régularité, pas la discriminabilité.
• Pas de résistance à l'oubli. Entraîner sur une tâche B dégrade fortement la tâche A, comme pour un réseau standard.
• Généralisation limitée sur les fonctions à décision dure. Sur des tâches synthétiques, KEEP généralise l'agrégation lisse (moyenne, somme, max) mais échoue sur la parité, le XOR, l'égalité exacte, et l'extrapolation hors du domaine vu.
• Échelle non explorée. Aucun résultat au-delà de quelques millions de paramètres.

---

Citation

@software{keep_ameforge,
  author = {},
  title  = {KEEP: predictive-error propagation over arbitrary neighborhoods},
  year   = {2026},
  url    = {https://huggingface.co/AMFORGE/KEEP-fashion-mnist},
  note   = {AMEFORGE}
}

---

AMEFORGE .