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

  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

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 :

  1. 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.
  2. 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.

  1. 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.
  2. 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.
  3. 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) :

  1. environnement (nvidia-smi, installation des dépendances) ;
  2. récupération du code ;
  3. jeton Hugging Face via les secrets Colab (jamais collé dans une cellule) ;
  4. vérification GPU et ressources ;
  5. attachement des sources gelées (mode eval, requires_grad=False) ;
  6. boucle d'entraînement (feature_fn : le seul élément spécifique à la tâche) ;
  7. ce que la boucle établit et n'établit pas ;
  8. 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.

Downloads last month

-

Downloads are not tracked for this model. How to track
Inference Providers NEW
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support