COGNITIVE-CORE Framework

🧠 Standard universel pour les architectures cognitives d'Ame Web Studio

🏗️ Structure

cognitive-core/
├── __init__.py              # Exports du package
├── cognitive_base.py        # Classes de base (Config, Modules, PreTrainedModel)
├── cognitive_checkpoint.py  # Chargement/sauvegarde avec remappage auto
├── cognitive_modules.py     # 🆕 TOUS les modules cognitifs réutilisables
├── cognitive_training.py    # Utilitaires d'entraînement
├── cognitive_utils.py       # Utilitaires (device, mémoire, tokens)
└── README.md               # Cette documentation

🚀 Installation

Option 1: Via Pip (Recommandé)

# Installation standard
pip install cognitive-core

# Avec support Vision
pip install "cognitive-core[vision]"

# Avec support Audio
pip install "cognitive-core[audio]"

# Avec support Entraînement (WandB/Tensorboard)
pip install "cognitive-core[training]"

# Installation Complète
pip install "cognitive-core[all]"

Option 2: Via Git (Dernière version)

pip install git+https://github.com/Volgat/nexus-standardisation.git

Option 3: Via HuggingFace

pip install git+https://huggingface.co/amewebstudio/cognitive-core

Option 4: Mode Développement (Local)

git clone https://github.com/Volgat/nexus-standardisation.git
cd nexus-standardisation
pip install -e .

Si vous n'utilisez pas pip, vous pouvez simplement ajouter le chemin :

import sys
sys.path.append("/path/to/standardisation")

from cognitive_core import *

📦 Modules Disponibles

Normalisation

Module	Description
RMSNorm	Root Mean Square Normalization (plus efficace que LayerNorm)

Encodage Positionnel

Module	Description
RotaryEmbedding	RoPE avec scaling pour contextes longs
SinusoidalPositionalEncoding	Encodage sinusoïdal classique

Attention

Module	Description
GroupedQueryAttention	GQA avec RoPE et KV-Cache
CrossAttention	Attention croisée pour fusion multimodale

Réseaux Feed-Forward

Module	Description
SwiGLU	Activation SwiGLU (meilleure que GELU)
MLP	MLP standard avec GELU

Mixture of Experts

Module	Description
Expert	Expert unique avec SwiGLU
SparseMoE	MoE sparse avec routing Top-K

Systèmes de Mémoire

Module	Description
ContrastiveLPOL	Mémoire LPOL avec 9 domaines de connaissances
MultiScaleMemory	Mémoire court/long terme avec consolidation
EpisodicMemory	Mémoire épisodique pour expériences

World Model

Module	Description
WorldBuffer	Buffer de monde unique avec prédiction
MultiWorldBuffer	Buffers multi-domaines (physical, social, abstract, temporal)

État Interne

Module	Description
NonVerbalTension	Tracker de tension basé sur erreur de prédiction
InternalState	État cognitif interne complet

Rêve & Identité

Module	Description
DreamPhase	Phase de rêve pour consolidation mémoire
SelfTrace	Tracking d'identité à travers le temps

Neurogenèse

Module	Description
NeurogenesisLayer	Couche avec naissance/mort dynamique de neurones

EARCP

Module	Description
EARCPModule	Ensemble Auto-Regulated Coherence Protocol

VAE (Vision/World Model)

Module	Description
VAEEncoder	Encodeur VAE convolutionnel
VAEDecoder	Décodeur VAE convolutionnel

Espace Latent Universel

Module	Description
UniversalLatentSpace	ULS pour alignement cross-modal (text, vision, audio)

🎯 Exemples d'Utilisation

Modèle de Langage Cognitif

from cognitive_core import (
    CognitiveConfig, CognitivePreTrainedModel,
    GroupedQueryAttention, SparseMoE, ContrastiveLPOL,
    MultiScaleMemory, RMSNorm
)

class MyLLMConfig(CognitiveConfig):
    model_type = "cognitive_llm"
    vocab_size = 50000

class MyCognitiveLayer(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.attn = GroupedQueryAttention(config.d_model, config.n_heads)
        self.moe = SparseMoE(config.d_model, config.d_ff, num_experts=8)
        self.norm1 = RMSNorm(config.d_model)
        self.norm2 = RMSNorm(config.d_model)
    
    def forward(self, x):
        x = x + self.attn(self.norm1(x))[0]
        moe_out, aux = self.moe(self.norm2(x))
        return x + moe_out, aux

World Model Cognitif

from cognitive_core import (
    CognitiveConfig, VAEEncoder, VAEDecoder,
    MultiWorldBuffer, EpisodicMemory, NeurogenesisLayer
)

class WorldModelConfig(CognitiveConfig):
    model_type = "cognitive_world"
    world_state_dim = 256

class CognitiveWorldModel(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.encoder = VAEEncoder(in_channels=3, latent_dim=256)
        self.decoder = VAEDecoder(latent_dim=256, out_channels=3)
        self.world = MultiWorldBuffer(config.d_model, config)
        self.memory = EpisodicMemory(config.d_model, config)
        self.neurogenesis = NeurogenesisLayer(256, 64, config)

Vision-Language Multimodal

from cognitive_core import (
    CognitiveConfig, UniversalLatentSpace, CrossAttention,
    ContrastiveLPOL, DreamPhase, SelfTrace
)

class MultimodalConfig(CognitiveConfig):
    model_type = "cognitive_multimodal"

class CognitiveMultimodal(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.uls = UniversalLatentSpace(config.d_model, config)
        self.cross_attn = CrossAttention(config.d_model)
        self.memory = ContrastiveLPOL(config.d_model, config)
        self.dream = DreamPhase(config.d_model, config)
        self.self_trace = SelfTrace(config.d_model, config)
    
    def forward(self, text_features, vision_features):
        # Fusion dans l'espace latent universel
        uls_out = self.uls({"text": text_features, "vision": vision_features})
        # Attention croisée
        fused = self.cross_attn(text_features, vision_features)
        # Mémoire
        mem_out = self.memory(fused)
        return mem_out["output"]

📊 Garanties du Standard

• ✅ Agnostique - Fonctionne pour LLM, Vision, Audio, World Model, Multimodal
• ✅ Composable - Tous les modules sont indépendants et combinables
• ✅ HuggingFace-Compatible - Hérite de PreTrainedModel
• ✅ Remappage Auto - Gère les différences de format de checkpoint
• ✅ Portabilité - Kaggle, Colab, Local sans modification

📄 Licence

PROPRIETARY - ALL RIGHTS RESERVED Copyright © 2026 Mike Amega (Logo) - Ame Web Studio