- NOEON
- Sommaire
- 1. Présentation officielle de NOEON
- 2. Vision du laboratoire Frankenstein-Labs
- 3. Capacités principales
- 4. Architecture neuronale
- 5. Fonctionnement multimodal
- 6. Context Window et mémoire
- 7. Raisonnement et intelligence
- 8. Paramètres et caractéristiques techniques
- 9. État réel de l'entraînement
- 10. Installation et utilisation
- 11. Exemples de code
- 12. Entraînement avec Google Colab
- 13. Évaluation et benchmarks
- 14. Documentation technique
- 15. Sources et provenance technique
- Sommaire
NOEON
Architecture d'intelligence artificielle multimodale unifiée — Frankenstein-Labs
NOEON est une architecture d'IA multimodale unifiée conçue pour faire interagir plusieurs capacités intelligentes — compréhension visuelle, utilisation d'interfaces informatiques et génération/retouche d'images — dans un espace de représentation partagé de 2560 dimensions.
NOEON n'est pas un routeur d'API et n'est pas un assemblage de trois modèles indépendants. Le travail original porte sur la conception de l'architecture, l'intégration des modalités, les composants de fusion et les mécanismes d'interaction entre capacités : des ponts neuronaux entraînables, un FusionCore partagé où les modalités s'attentionnent mutuellement, et une tête de génération qui conditionne la synthèse d'image sur l'état fusionné.
Transparence. La version actuelle est une étape de développement. Les poids de NOEON sont initialisés mais non entraînés ; les modèles amont qui alimentent les capacités sont gelés et appartiennent à leurs projets respectifs. Aucune capacité n'est présentée comme opérationnelle avant validation technique. Voir la section État réel de l'entraînement.
Sommaire
- Présentation officielle de NOEON
- Vision du laboratoire Frankenstein-Labs
- Capacités principales
- Architecture neuronale
- Fonctionnement multimodal
- Context Window et mémoire
- Raisonnement et intelligence
- Paramètres et caractéristiques techniques
- État réel de l'entraînement
- Installation et utilisation
- Exemples de code
- Entraînement avec Google Colab
- Évaluation et benchmarks
- Documentation technique
- Sources et provenance technique
1. Présentation officielle de NOEON
| Nom officiel | NOEON |
| Laboratoire | Frankenstein-Labs |
| Créateur et fondateur | Abdoulaye Coumbassa |
| Nature | architecture multimodale unifiée |
| Espace partagé | 2560 dimensions |
| Dépôt officiel | https://huggingface.co/Frankenstein-Labs/NOEON |
| Licence du code NOEON | Apache-2.0 |
NOEON traite trois flux de capacités dans un seul espace de représentation.
Chaque flux est nommé par ce qu'il fait dans NOEON — vision,
computer_use, generation — et non par le modèle qui l'alimente. Les
modalités ne coexistent pas : elles interagissent dans les mêmes paramètres,
au sein d'un transformer partagé, ce qui est le cœur de l'architecture.
L'identité officielle du projet, sa direction et la séparation stricte entre
composants originaux, composants externes et composants futurs sont documentées
dans docs/IDENTITY.md.
2. Vision du laboratoire Frankenstein-Labs
Frankenstein-Labs développe NOEON comme une architecture propriétaire : l'objectif est que, progressivement, l'ensemble des poids, des composants neuronaux, des adaptateurs, du FusionCore, des mécanismes de raisonnement, des systèmes de mémoire, des mécanismes de vision, des systèmes de génération d'images et des mécanismes Computer Use soient développés et entraînés par Frankenstein-Labs.
Cette ambition est la direction du projet. Les composants concernés ne sont pas encore terminés, et la feuille de route les distingue explicitement des éléments déjà développés :
| Composant visé | Statut réel |
|---|---|
NOEON-Vision |
futur |
NOEON-Computer |
futur |
NOEON-Generation |
futur |
NOEON-FusionCore |
architecture développée et testée, non entraînée |
NOEON-Reasoning |
futur |
NOEON-Memory |
futur |
NOEON-Embeddings |
futur |
NOEON-Shared-Representation |
espace 2560-d défini, ponts à entraîner |
La structure d'accueil des futurs poids propriétaires est déjà en place dans
weights/noeon/, et le plan de remplacement des
composants externes est décrit dans docs/TRANSITION.md.
3. Capacités principales
NOEON vise l'intégration de plusieurs capacités dans une architecture unique. Le tableau ci-dessous indique, pour chacune, ce qu'elle vise et son état réel.
| Capacité | Objectif | État réel |
|---|---|---|
| Vision artificielle | compréhension multimodale des images et contenus visuels | flux connecté, non entraîné |
| Compréhension visuelle | lecture et interprétation d'images | flux connecté, non entraîné |
| Computer Use | compréhension et utilisation d'interfaces informatiques | flux connecté + espace d'actions GUI réel, non entraîné |
| Interaction graphique | agir sur des environnements graphiques | espace d'actions implémenté, non entraîné |
| Génération d'images | synthèse d'images | chemin de conditionnement 2560-d vérifié, non entraîné |
| Retouche d'images | modification d'images | latents d'édition supportés, non entraîné |
| Instructions complexes | compréhension d'instructions détaillées | dépend de l'entraînement |
| Fusion multimodale | attention inter-modalités dans un transformer partagé | architecture implémentée et testée |
| Représentation partagée | espace commun de 2560-d | mesuré sur les tenseurs réels |
| Interaction inter-modale | collaboration entre capacités | mécanisme implémenté, à entraîner |
Les capacités partagent un espace de représentation unique. Un token issu de la vision peut s'attentionner sur un token de computer use, qui peut s'attentionner sur un token de génération : c'est le mécanisme par lequel les compétences collaborent au lieu de simplement coexister.
Aucune capacité n'est présentée comme opérationnelle. Toutes les capacités dépendent d'un entraînement qui n'a pas encore été exécuté.
4. Architecture neuronale
gelé, jamais modifié entraînable (NOEON)
┌────────────────────────────────┐ ┌────────────────────────────────────┐
│ vision (source gelée) │─états▶│ BridgeAdapter("vision") │
│ computer_use (source gelée) │─états▶│ BridgeAdapter("computer_use") │
│ generation (source gelée) │─ctx──▶│ BridgeAdapter("generation") │
└────────────────────────────────┘ └─────────────────┬──────────────────┘
│ tous en 2560-d
▼
┌────────────────────────────────────────┐
│ FusionCore — transformer partagé │
│ + Modal Embeddings │
│ + embeddings positionnels partagés │
│ + Cross-Modal Interaction (attention) │
└─────────────────┬──────────────────────┘
▼
Shared Representation (2560-d)
│
▼
GenerationHead ──▶ contexte de génération
Composants
| Composant | Rôle | Emplacement |
|---|---|---|
| Vision Bridge | mappe les états du flux vision vers l'espace partagé |
noeon/core/bridge.py |
| Computer Use Bridge | mappe les états du flux computer_use |
noeon/core/bridge.py |
| Generation Bridge | mappe le conditionnement du flux generation |
noeon/core/bridge.py |
| FusionCore | transformer partagé sur la concaténation des flux | noeon/architecture/fusion.py |
| GenerationHead | projette l'état fusionné vers le contexte 2560-d de la génération | noeon/architecture/model.py |
| Shared Representation Space | espace commun de 2560-d | noeon/core/config.py |
| Modal Embeddings | embeddings de modalité appris | noeon/architecture/fusion.py |
| Cross-Modal Interaction | attention sur toutes les modalités concaténées | noeon/architecture/fusion.py |
| Frozen Upstream Models | modèles amont gelés qui alimentent les flux | voir docs/PROVENANCE.md |
Ponts neuronaux
Chaque pont est un adaptateur entraînable de bas rang (rank = 128) avec un
delta LoRA optionnel (lora_rank = 16). Deux propriétés comptent :
- Initialisation à l'identité. La projection résiduelle et la matrice
montante démarrent à zéro : à l'étape 0, le pont est un passthrough exact
(
x + 0). L'entraînement ne peut qu'ajouter de la structure ; il ne peut pas corrompre le comportement gelé au premier jour. C'est le mécanisme concret de préservation des connaissances. - Bas rang. La surface entraînable est un goulot étroit : les modèles amont à plusieurs milliards de paramètres restent gelés.
Noyau de fusion (FusionCore)
Un unique transformer partagé (dim 2560, profondeur 8, 20 têtes, MLP ×4) traite la concaténation de tous les flux bridgés, chacun étiqueté par un embedding de modalité appris et un embedding positionnel partagé. L'attention porte sur l'ensemble des modalités, ce qui rend possible l'interaction inter-modale.
Tête de génération (GenerationHead)
GenerationHead projette l'état fusionné (poolé) vers un vecteur 2560-d, que
noeon/image_generation/conditioning.py étend en une séquence de
conditionnement (B, L, 2560). Le transformeur de diffusion lui-même reste
gelé : il n'est que conditionné.
5. Fonctionnement multimodal
Le fonctionnement multimodal de NOEON repose sur trois idées.
- Un espace partagé, mesuré. Les trois flux exposent réellement une largeur
cachée de 2560 (vérifié sur les en-têtes safetensors réels, voir
docs/COMPAT.md). Cette largeur commune est nécessaire pour qu'un pont soit possible ; elle n'est pas considérée comme suffisante : les ponts sont entraînés, pas supposés fonctionner. - Une interaction dans les mêmes paramètres. Comme l'attention porte sur la concaténation des modalités, les flux ne sont pas des canaux séparés mais des parties d'une même séquence traitée par le même transformer.
- Des connexions apprises. Rien ne route ni ne choisit entre les modèles : les ponts sont entraînés, et les modèles amont restent gelés et récupérables.
6. Context Window et mémoire
Ces valeurs sont des objectifs d'ingénierie, pas des capacités déjà vérifiées. Aucune fenêtre de contexte n'est présentée comme effective avant validation technique.
Fenêtre de contexte — feuille de route
| Étape | Fenêtre cible | Objectif |
|---|---|---|
| Étape 1 | 128K tokens | conversations longues, instructions complexes, analyse de documents et de code |
| Étape 2 | 256K tokens | analyse de projets volumineux, continuité des conversations, plusieurs documents simultanés |
| Étape 3 | 1M tokens | objectif expérimental à long terme : très grands ensembles documentaires, projets complexes, longues sessions de travail |
Aujourd'hui, le FusionCore accepte jusqu'à 8192 positions (max_tokens
réel de configs/noeon.yaml). Les cibles ci-dessus restent à développer.
Système de contexte — implémenté et testé
Le système de contexte est désormais du code réel (noeon/context/, 14
tests). Il distingue explicitement trois niveaux :
| Niveau | Où | Taille |
|---|---|---|
| Fenêtre native | dans le modèle amont | fixe — NOEON ne la modifie jamais |
| Mémoire externe NOEON | hors modèle | non bornée |
| Données persistantes | disque | non bornée |
Ajouter de la mémoire externe n'agrandit la fenêtre native d'aucun modèle :
elle change seulement ce qui est choisi pour l'occuper. Les niveaux de mémoire
sont : conversation (turns), travail (working), tâche (task), long terme
(MemoryStore). La récupération est lexicale (BM25) avec option dense/hybride.
ContextWindow.assemble garantit un budget dur et compresse l'historique de
façon extractive (pas un résumé appris — futur NOEON-Reasoning).
Détails : docs/CONTEXT.md.
7. Raisonnement et intelligence
NOEON dispose d'une couche de coopération multimodèle réelle (noeon/comm/,
22 tests + 5 tests d'intégration) : un protocole de messages standardisé, un bus
avec délais/reprises/confinement, une vérification des résultats, et un
coordinateur qui exécute des plans multi-étapes avec partage de contexte,
demandes d'aide et anti-conflit. Ce n'est pas un routeur.
Détails : docs/COMMUNICATION.md.
| Capacité cognitive | Statut |
|---|---|
| Compréhension des instructions | dépend de l'entraînement |
| Analyse multimodale | mécanisme d'architecture en place, non entraîné |
| Raisonnement sur contenus visuels | futur (NOEON-Reasoning) |
| Planification de tâches | mécanique réelle (RulePlanner, déterministe) ; planificateur appris futur |
| Résolution de problèmes | futur |
| Compréhension du contexte | implémentée et testée (voir mémoire, §6) |
| Interaction entre modalités | mécanisme implémenté, non entraîné |
| Continuité des tâches longues | mémoire persistante implémentée ; qualité dépend de l'entraînement |
8. Paramètres et caractéristiques techniques
| Caractéristique | Valeur (vérifiée) |
|---|---|
| Espace partagé | 2560 dimensions |
| Profondeur du FusionCore | 8 couches |
| Têtes d'attention | 20 |
| Rang des adaptateurs (ponts) | 128 |
| Rang LoRA | 16 |
| Ratio MLP | 4.0 |
| Positions maximales (FusionCore) | 8192 tokens |
| Modalités | 3 (vision, computer_use, generation) |
| Paramètres entraînables | 698 268 161 |
| Paramètres des sources gelées | 18 209 675 136 |
| Tenseurs NOEON produits | 126 |
Largeurs réelles des flux amont (mesurées sur les tenseurs, docs/COMPAT.md) :
les trois capacités exposent la dimension 2560. La vision et computer_use
partagent 298 tenseurs de formes identiques, 0 conflit après normalisation
des préfixes.
9. État réel de l'entraînement
Les poids actuels sont initialisés mais non entraînés.
| Élément | État |
|---|---|
| Ponts neuronaux | initialisés à l'identité (passthrough exact) |
| FusionCore | initialisé aléatoirement |
| Tête de génération | initialisée aléatoirement |
| Entraînement exécuté | aucun (environnement de préparation sans GPU) |
| Checkpoint entraîné | aucun |
| Benchmark publié | aucun (il n'existe aucun checkpoint entraîné à évaluer) |
Chaque fichier produit est étiqueté state: initialized-untrained dans
weights/MANIFEST.md. Aucun résultat d'entraînement n'est
fabriqué. Aucune capacité n'est revendiquée comme validée.
10. Installation et utilisation
pip install -r requirements.txt
python -m pytest tests/ -q # 90 tests, 1 skipped
# charger NOEON initialisé et exécuter une passe avant fusionnée
python - <<'PY'
import torch
from noeon.inference.run import load_pretrained
model, meta = load_pretrained("weights/noeon-init")
print("state:", meta["state"]) # initialized-untrained
out = model({"vision": torch.randn(1, 8, 2560),
"computer_use": torch.randn(1, 4, 2560),
"generation": torch.randn(1, 4, 2560)})
print(out["fused"].shape, out["gen_context"].shape) # (1,2560) (1,2560)
PY
Poids amont (stockés dans ce dépôt)
Les poids des trois modèles sources sont conservés dans ce dépôt, gelés et
intacts, sous weights/upstream/<slot>/ — 119 fichiers, 37.803 GB, SHA-256
vérifiés contre les dépôts d'origine (voir docs/IMPORT_REPORT.md).
# réimport/resynchronisation (idempotent, reprend là où il s'est arrêté)
HF_TOKEN=... python scripts/import_sources_to_hf.py
# tests de chargement depuis le Hub
HF_TOKEN=... python scripts/test_loading_from_hub.py
11. Exemples de code
Construire NOEON et lire son budget de paramètres :
python scripts/build_model.py
from noeon.architecture.model import Noeon
from noeon.core.config import NoeonConfig
model = Noeon(NoeonConfig())
print("entraînable :", f"{model.trainable_parameters():,}")
print("sources gelées :", model.frozen_sources())
Conditionner une génération à partir d'un état fusionné :
import torch
from noeon.architecture.model import Noeon
from noeon.core.config import NoeonConfig
from noeon.image_generation.conditioning import build_context
model = Noeon(NoeonConfig()).eval()
out = model({"vision": torch.randn(1, 8, 2560),
"generation": torch.randn(1, 4, 2560)})
ctx = build_context(out["gen_context"], length=512) # (1, 512, 2560)
print(ctx.shape)
Parser une action Computer Use :
from noeon.computer_use.action import parse_action
print(parse_action("click(120, 340)")) # click(120, 340)
12. Entraînement avec Google Colab
Le parcours GPU est préparé dans
notebooks/NOEON_TRAIN_COLAB.ipynb
(10 cellules) :
- environnement (
nvidia-smi, installation des dépendances) ; - récupération du code ;
- jeton Hugging Face via les secrets Colab (jamais collé dans une cellule) ;
- vérification GPU et ressources ;
- attachement des sources gelées (mode eval,
requires_grad=False) ; - boucle d'entraînement (
feature_fn: le seul élément spécifique à la tâche) ; - ce que la boucle établit et n'établit pas ;
- publication optionnelle des checkpoints.
Sur un hôte GPU :
HF_TOKEN=... python scripts/train_with_sources.py --steps 200 --batch 1
L'entraînement exige un GPU et les poids amont. En leur absence, le script refuse de s'exécuter et explique pourquoi, plutôt que de basculer silencieusement sur des données synthétiques.
13. Évaluation et benchmarks
Le harnais noeon/evaluation/harness.py mesure,
sur des tenseurs réels :
| Métrique | Ce qu'elle mesure |
|---|---|
teacher_alignment_cosine |
l'état fusionné suit-il les enseignants gelés ? |
generation_mse |
le vecteur de conditionnement est-il proche de la cible ? |
bridge_retention_cosine |
le pont reste-t-il proche du passthrough (rétention) ? |
Aucun résultat de benchmark n'est publié. Il n'existe aucun checkpoint
entraîné à évaluer. Les seules valeurs vérifiées aujourd'hui sont
structurelles : dimensions, nombre de paramètres, compatibilité des formes, et
une passe avant sur des octets réels des sources
(scripts/verify_real_weights.py).
14. Documentation technique
| Document | Contenu |
|---|---|
docs/IDENTITY.md |
identité officielle, laboratoire, créateur, direction |
docs/ARCHITECTURE.md |
architecture détaillée |
docs/WEIGHTS.md |
organisation des poids (actuels et propriétaires) |
docs/TRAINING.md |
système d'entraînement |
docs/ROADMAP.md |
feuille de route (contexte, mémoire, composants) |
docs/TRANSITION.md |
plan de transition vers des composants propriétaires |
docs/STATUS.md |
état du projet, honnêtement |
docs/VERIFICATION.md |
preuves de vérification (octets réels) |
docs/COMPAT.md |
compatibilité des tenseurs amont |
docs/SOURCES.md |
provenance, accès, licences des sources |
docs/PROVENANCE.md |
attribution et correspondance des capacités |
docs/AUDIT.md |
audit des modèles amont |
docs/TRANSFER.md |
transfert vers Hugging Face |
15. Sources et provenance technique
NOEON ne revendique pas la création des poids amont. La version actuelle
s'appuie sur trois modèles amont gelés, référencés par dépôt et révision et
jamais redistribués comme poids NOEON ni modifiés. L'attribution complète
(repos, révisions, licences) est dans
docs/PROVENANCE.md et
docs/SOURCES.md.
| Capacité NOEON | Source amont (attribution) | Licence |
|---|---|---|
vision |
voir docs/PROVENANCE.md |
Apache-2.0 |
computer_use |
voir docs/PROVENANCE.md |
Apache-2.0 |
generation |
voir docs/PROVENANCE.md |
MIT |
Ces composants sont temporaires : ils seront remplacés progressivement par
les composants propriétaires de Frankenstein-Labs (voir
docs/TRANSITION.md).
Licence
Le code et la configuration propres à NOEON sont publiés sous Apache-2.0. Cela ne relicencie pas les composants amont : chaque modèle amont conserve sa licence (Apache-2.0 / MIT). NOEON ne redistribue pas les poids amont comme les siens.
Frankenstein-Labs — créé et dirigé par Abdoulaye Coumbassa.