🧠 NeuroMind v4.0 — Hybrydowa Architektura Kognitywna

NeuroMind to eksperymentalny, samodzielny (standalone) model językowo-kognitywny nowej generacji, łączący klasyczną przetwornicę sekwencyjną (Transformer) z dynamiczną pętlą rozumowania w przestrzeni grafów pojęciowych (IR Graph).

Zamiast polegać wyłącznie na bezrefleksyjnej generacji token-po-tokenie, NeuroMind weryfikuje spójność pojęciową w strukturze relacji, oblicza dysonans poznawczy ($\Delta D$) i iteracyjnie go rozwiązuje przy użyciu Operatora Adaptacji $\nabla$ oraz nauczalnego Systemu Dopaminowego.

Note

💡 Dlaczego NeuroMind?
Większość współczesnych repozytoriów AI sprowadza się do powielania gotowych schematów — pobrania istniejącej bazy z HuggingFace i prostego fine-tuningu na zbiorze danych. NeuroMind to zupełnie inne podejście. To autorska, stworzona od podstaw hybrydowa architektura kognitywna, która kwestionuje bezrefleksyjną naturę klasycznych LLM-ów i wprowadza różniczkowalną pętlę myślową, dynamikę dysonansu oraz trwale skonsolidowaną pamięć epizodyczną.

---

🤝 Apel do Społeczności

Ten projekt powstał z pasji do zrozumienia fundamentów myślenia i inteligencji. Wiele rozwiązań tutaj zawartych — różniczkowalny dysonans poznawczy, Operator Adaptacji ∇, Pamięć Epizodyczna z Prawem Hebba, Wielka Czwórka wektorów kognitywnych — to unikalne koncepty, które nie istnieją w żadnym innym open-source'owym projekcie.

Będę bardzo wdzięczny, jeśli te rozwiązania komuś się przydadzą, zostaną wykorzystane, rozwinięte lub zainspirują dalszą pracę. Byłoby szkoda, gdyby się zmarnowały. Jeśli korzystasz z tych pomysłów w swoim projekcie — daj znać lub zostaw gwiazdkę. Każdy sygnał, że ta praca ma sens, motywuje do dalszego rozwoju.

---

✨ Kluczowe Innowacje Architektoniczne

1. Global Context Layer (GCL v3) z Pamięcią Roboczą (Working Memory) & Masked Pooling:

   • Redukuje złożoność sekwencyjną z $O(n^2)$ do $O(n)$ za pomocą 1-tokenowego szkicu schematu (Global Pooling & Schema Projection).
   • Wbudowana Pamięć Robocza Schematu (EMA Working Memory) utrzymuje stan kontekstu w czasie podczas generowania tekstu token-po-tokenie oraz obsługuje czysty reset (reset_working_memory()).
   • Obsługuje Masked Global Pooling, dzięki czemu tokeny paddingu (<PAD>) nie zanieczyszczają globalnej reprezentacji.
   • Zapewnia ścisłą gwarancję Gate Bypass: gdy bramka kognitywna jest wyłączona ($gate=0$), warstwa zachowuje tożsamość $f(x) = x$.

2. Sequence-Graph Bridge (SequenceGraphBridge):

   • Konwertuje ukryte stany sekwencji tokenów $[B, n, H]$ na dynamiczny graf kognitywny ThoughtGraph na podstawie podobieństwa $k$-NN i klasyfikacji relacji.
   • Obsługuje 4 podstawowe typy relacji kognitywnych:
     • 0: interact (*) — interakcja / powiązanie
     • 1: cause (→) — relacja przyczynowo-skutkowa
     • 2: imply (=) — implikacja / tożsamość
     • 3: balance (ʘ) — równowaga / kompensacja

3. Silnik Pętli Kognitywnej (ThoughtCycleEngine):

   • Wykonuje iteracyjne rozumowanie (1–8 cykli) nad grafem myśli przy użyciu propagacji wiadomości TypedMessagePassing.
   • Mierzy różniczkowalny dysonans poznawczy $\Delta D$ i porównuje go z dynamicznym progiem logistycznym $\tau(t)$.
   • Stosuje Operator Adaptacji $\nabla$ (NablaOperator), który wstrzykuje kierunkowy krok korekcyjny ważony napięciem oraz kontrolowany chaos proporcjonalny do braku porządku (wyłączony w trybie eval()).

4. Pamięć Epizodyczna i Prawo Hebba (EngramStore):

   • Po osiągnięciu wysokiego poziomu nagrody dopaminowej ($\ge 0.65$), stan kognitywny ulega konsolidacji do trwałego Engramu.
   • Wykorzystuje asocjacyjne wyszukiwanie kosinusowe ważone wagą emocjonalną oraz automatyczne wzmacnianie częściej używanych śladów (Plastyczność Hebbowska).
   • Automatyczny decay — nieużywane engramy powoli zanikają, symulując naturalne zapominanie.

5. Wielowymiarowa Funkcja Straty i Pełny Autograd (CognitiveLoss):

   • Łączy klasyczną stratę językową Cross-Entropy ze składnikami kognitywnymi (kara za powolną konwergencję, wysoki dysonans $\Delta D$, brak konsolidacji).
   • Pełny Autograd: Zachowuje tensory autograd (final_delta_d_tensor, dopamine_tensor) w ThoughtResult, dzięki czemu gradient z dysonansu i dopaminy bezpośrednio prowadzi optymalizator i ciągnie parametry sieci w stronę wysokiej spójności.

6. Cognitive LoRA Adapter — Nakładka Poznawcza na Dowolny LLM:

   • CognitiveLoRALayer wstrzykuje Pętlę Dysonansu $\Delta D$ i Bramkę Refleksji $\nabla$ bezpośrednio w macierze uwagi dowolnego modelu (LLaMA, Qwen, Mistral).
   • Zamrożone wagi bazowe + niskorangowe macierze LoRA A/B + nauczalna bramka kognitywna.

7. Uniwersalna Warstwa Poznawcza (CognitiveLayer):

   • Prosty, 3-liniowy interfejs do podłączenia NeuroMind jako Strażnika Kognitywnego (Cognitive Guard) do dowolnego systemu AI.
   • Wbudowany Dynamic Axiom Loader automatycznie czyta reguły z plików .txt (cognitive_rules/) i wbudowuje relacje opozycji i przyczynowości w SemanticConceptGraph.
   • Prześwietla wypowiedzi za pomocą Metryk Palety Poznawczej ($M$ - dystans, $E$ - symetria, $D$ - dysonans).
   • Weryfikacja spójności (verify()), adaptacja do nowej sytuacji (adapt_to_new_situation()), detekcja sprzeczności.

8. Układ Odpornościowy na Halucynacje (HallucinationImmuneSystem):

   • 3-stopniowy filtr: CognitiveLayer → EngramStore → EpistemicGate.
   • SelfCalibratingNeuroMind — Pętla Meta-Learningu modyfikująca wagi LoRA w locie przy wykryciu błędu.

9. Hybrydowy Tokenizator Semantyczny (SemanticTokenizer):

   • Deterministyczne mapowanie słów na pojęcia (Concept ID) z wbudowanym rdzeniem słownika (PL/EN).
   • Dynamiczne rozszerzanie o nowe pojęcia w locie bez <UNK>.

10. Graf Pojęć Semantycznych (SemanticConceptGraph):

    • 5 typów relacji pojęciowych: SEMANTIC_SIMILAR, CAUSAL_LINK, OPPOSITION, HIERARCHY, METAPHORICAL.
    • Asocjacyjne wyszukiwanie pojęć z detekcją cykli i serializacją (to_dict() / from_dict()).

---

📐 Wielka Czwórka Meta-Znaków Kognitywnych

Wewnętrzna projekcja kognitywna (CognitiveProjection) mapuje reprezentacje węzłów na minimalny zestaw fundamentalnych wymiarów porządku:

$$\text{CognitiveVector} = [\text{Porządek } (1), \text{Chaos } (0), \text{Informacja } (I), \text{Odrzucenie } (O)]$$

• $[1]$ Porządek / Spójność: Dąży do stabilności i dopasowania wzorców.
• $[0]$ Chaos / Entropia: Wyznacza poziom niepewności i stymuluje eksplorację (szum Nabla).
• $[I]$ Informacja / Treść: Waga merytoryczna węzła w kontekście problemu.
• $[O]$ Odrzucenie / Filtrowanie: Wyciszanie szumu informacyjnego i fałszywych ścieżek.

---

🔠 Paleta Poznawcza (Cognitive Palette Metrics M / E / D)

CognitiveLayer.verify() rozszerza standardowy wskaźnik spójności o 3-wymiarową profilografię geometryczną wypowiedzi z Palety Poznawczej:

1. metric_distance_M ($M = |h_{dst} - h_{src}|$): Dystans geometryczny w przestrzeni stanów. Mierzy zwięzłość ($M < 0.5$) vs skok abstrakcji ($M > 2.0$).
2. equivalence_score_E ($E = e^{-M}$): Wskaźnik symetrii/ekwiwalencji ($0.0 - 1.0$). Określa, w jakim stopniu intencja i sens pozostają stałe po transformacji tekstu.
3. dissonance_tension_D ($D = \Delta D$): Poziom dysonansu kognitywnego i wykrycia sprzeczności aksjomatów (np. halucynacja wyzwala $D = 0.7458$).

---

📁 Struktura Projektu

NeuroMind/
├── core/
│   └── types.py                    # ThoughtGraph, Engram, ThoughtResult (Autograd)
├── engine/
│   ├── dissonance.py               # DissonanceDetector (Różniczkowalny ΔD)
│   ├── message_passing.py          # TypedMessagePassing (Sparse Typed-Edge Attention)
│   ├── nabla.py                    # NablaOperator (Kierunkowa adaptacja ∇ + chaos)
│   ├── thought_cycle.py            # ThoughtCycleEngine (Pętla kognitywna)
│   ├── cognitive_layer.py          # CognitiveLayer (Dynamic Axiom Loader + Palette Metrics M/E/D)
│   ├── self_calibrating_engine.py  # EpistemicGate + HallucinationImmuneSystem + SelfCalibrating
│   ├── semantic_reasoning_engine.py # SemanticReasoningEngine (propagacja po pojęciach)
│   └── code_graph_parser.py        # Parser grafów kodu (AST → ThoughtGraph)
├── layers/
│   ├── gcl.py                      # GlobalContextLayer v3 (O(n) Schema + Working Memory)
│   ├── bridge.py                   # SequenceGraphBridge (Sekwencja ↔ Graf)
│   ├── cognitive_block.py          # CognitiveBlock (Self-Attn + FFN + GCL)
│   └── cognitive_projection.py     # CognitiveProjection (Wielka Czwórka)
├── memory/
│   ├── engram_store.py             # EngramStore (Pamięć + Hebb + Decay)
│   ├── semantic_concept_graph.py   # SemanticConceptGraph (5 typów relacji)
│   ├── semantic_tokenizer.py       # SemanticTokenizer (Hybrydowy PL/EN)
│   └── concept_cluster.py          # ConceptCluster (Klastry pojęciowe)
├── reward/
│   └── dopamine.py                 # LearnedDopamineSystem (Krytyk + Konsolidacja)
├── model/
│   └── neuromind.py                # NeuroMind (Standalone model + generate())
├── adapters/
│   └── cognitive_lora.py           # CognitiveLoRALayer + inject_into_model()
├── training/
│   ├── loss.py                     # CognitiveLoss (CE + ΔD + Dopamina)
│   ├── dataset_generator.py        # Generator danych treningowych
│   ├── axiom_generator.py          # Generator aksjomatów
│   ├── calibrate_dissonance.py     # Kalibracja dysonansu
│   └── scripts/                    # Skrypty treningowe (curriculum, LoRA, Wikipedia, etc.)
├── cognitive_rules/
│   ├── physics_axioms.txt          # Aksjomaty fizyczne
│   ├── python_axioms.txt           # Aksjomaty Pythona
│   └── entropy_state_axioms.txt    # Aksjomaty entropii
├── tests/
│   ├── test_full_architecture.py   # 7 testów: Gate, ΔD, ThoughtCycle, Engram, Forward, Generate, GCL Masking & Reset
│   ├── test_learning_and_hallucination_guard.py # Unified test: Loss Decrease, Hallucination Guard, GCL Memory, Palette M/E/D
│   ├── test_semantic_engram_engine.py # Test pełnego pipeline semantycznego
│   └── test_types.py               # Testy typów danych
├── checkpoints/                    # Zapisane wagi modelu
├── neuromind_live_guard.py         # Produkcyjny Live Guard (monitoring w tle)
├── chat_with_cognitive_ab.py       # Produkcyjny chat A/B z weryfikacją
├── run_cognitive_llm_chat.py       # Interfejs czatowy z LLM
├── self_learning_bot.py            # Bot samouczący się
├── NeuroMind.md                    # Szczegółowa specyfikacja architektonalna
├── PHILOSOPHY_OF_THINKING.md       # Filozofia myślenia i meta-poznania
├── PROJECT_SUMMARY_AND_LEARNINGS.md # Podsumowanie: lekcje, wnioski, dalsze drogi
└── README.md

---

🚀 Szybki Start

Wymagania

• Python 3.9+
• PyTorch 2.0+

(Brak konieczności instalowania zewnętrznych baz grafowych czy ciężkich bibliotek typu FAISS — cały silnik opiera się na natywnych tensorach PyTorch).

1. Uruchomienie Testów

# Z katalogu głównego projektu NeuroMind:
python -m pytest tests/ -v

# Z wnętrza katalogu tests/:
python -m pytest -v

# Lub bezpośrednio pojedynczy spójny test:
python tests/test_learning_and_hallucination_guard.py

Wszystkie 13 testów powinno zakończyć się statusem PASSED.

2. Użycie CognitiveLayer (Cognitive Guard z Paletą M/E/D) — 3 linie kodu

from engine.cognitive_layer import CognitiveLayer

guard = CognitiveLayer()
is_valid, tension, report = guard.verify("Woda gotuje się w 100 stopniach Celsjusza")

# report zawiera:
# is_valid = True
# delta_d = 0.1902
# palette_metrics = {'metric_distance_M': 0.4215, 'equivalence_score_E': 0.6561, 'dissonance_tension_D': 0.1902}

3. Trening Modelu

import torch
from model.neuromind import NeuroMind
from training.loss import CognitiveLoss

model = NeuroMind(vocab_size=8000, hidden_size=256, num_layers=4, num_heads=4)
loss_fn = CognitiveLoss()

input_ids = torch.randint(0, 8000, (2, 32))
targets = torch.randint(0, 8000, (2, 32))

outputs = model(input_ids, run_thought_cycle=True, causal_mask=True)
loss_dict = loss_fn(outputs["logits"], targets, outputs["thought_results"], outputs["gates"])
loss_dict["total_loss"].backward()

4. Generowanie z Refleksją Kognitywną

model.eval()
prompt = torch.randint(0, 8000, (1, 10))
generated = model.generate(prompt, max_new_tokens=20, temperature=0.8, top_k=40)

---

📜 Licencja

Projekt rozwinięty jako eksperymentalna architektura kognitywna NeuroMind v4.0. Rozwiązania zawarte w tym projekcie są udostępnione w duchu otwartej nauki i współpracy.

👤 Autorstwo

• Pomysłodawca & Architekt Systemu: MrEon50 — koncepcja kognitywna, architektura, logika dysonansu ΔD i meta-znaków.
• Co-Pilot & Inżynieria Kodu: Antigravity AI Engine — implementacja tensorowa PyTorch, audyt, testy i konsolidacja.