Skip to content

About

No description or website provided.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Repository files navigation

GIA - General Intelligence Architecture

   ██████╗ ██╗ █████╗ 
  ██╔════╝ ██║██╔══██╗
  ██║  ███╗██║███████║
  ██║   ██║██║██╔══██║
  ╚██████╔╝██║██║  ██║
   ╚═════╝ ╚═╝╚═╝  ╚═╝

General Intelligence Architecture

GIA to jeszcze nie AGI. To jest: Działający prototyp alternatywnej architektury AI, która próbuje rozwiązać fundamentalne ograniczenia LLM (brak pamięci, emocji, self-modelu, ciągłego uczenia) poprzez integrację wielu systemów w jedną całość z centralnym punktem "świadomości" (Φ_t).

Jest to eksperyment architektoniczny i punkt wyjścia do dalszych badań, nie gotowe AGI. Ale sam fakt, że system działa i wszystkie komponenty współpracują - to już jest wartość, bo pokazuje, że taka integracja jest możliwa.


📋 Opis

GIA to wielowarstwowa architektura AI zaprojektowana do wykazywania ludzkopodobnych (a nawet przekraczających ludzkie) możliwości poznawczych. System integruje:

  • Dynamiczną tokenizację z masowym, szybkim przetwarzaniem
  • Asocjacyjną pamięć łączącą fakty, emocje i model siebie
  • Ewolucję symbolicznych reguł z selekcją naturalną
  • Neuro-symboliczne planowanie z MCTS i emotional utility
  • Centralny punkt świadomości (Consciousness Anchor) - wektor Φ_t

🏗️ Architektura

Warstwy Systemu

Warstwa Komponenty Funkcja
0 CT-X, SEG, CBP Tokenizacja, sparse embeddings, bufor cykliczny
1 HAM (SG + EL + SMB) Hybrid Associative Memory - graf semantyczny, emocje, model siebie
2 RE, CM, ATS Rule Evolution - ewolucja reguł, konflikty, antyteza-synteza
3 AHN, RSF, MCTS Neuro-symbolic Planner - scoring, fuzja, planowanie
4 AE, MC, CA Emotional Loop - afekt, motywacja, świadomość (Φ_t)

Cykl HRM (Hybrid Recurrent Module)

1. SENSING       → CT-X tokenizuje wejście
2. ENCODING      → HAM asocjacyjnie łączy tokeny  
3. AFFECTIVE     → AE przydziela emocje
4. RULE UPDATE   → RE aktualizuje posteriors, ATS
5. SCORING       → AHN + RSF + CM oceniają reguły
6. MCTS SIMULATE → symulacja sekwencji akcji
7. DECISION      → wybór akcji przez Φ_t
8. FEEDBACK      → decay, aktualizacja, sen

📁 Struktura Projektu

GIA/
├── src/
│   ├── core/
│   │   ├── consciousness_anchor.py   # CA - punkt świadomości, Φ_t
│   │   └── hrm_loop.py               # Główny cykl HRM
│   ├── tokenizer/
│   │   ├── continuous_tokenizer.py   # CT-X - tokenizator
│   │   └── sparse_embedding.py       # SEG + CBP
│   ├── memory/
│   │   ├── semantic_graph.py         # SG - graf semantyczny
│   │   ├── emotion_lattice.py        # EL - siatka emocji
│   │   ├── self_model_buffer.py      # SMB - model siebie
│   │   └── hybrid_memory.py          # HAM - integracja
│   ├── rules/
│   │   ├── rule_base.py              # Baza reguł IF-THEN
│   │   ├── evolution.py              # Mutacja, krzyżowanie, ATS
│   │   └── conflict_manager.py       # Zarządzanie konfliktami
│   ├── planner/
│   │   ├── hyper_network.py          # AHN - adaptive hyper-network
│   │   └── mcts_planner.py           # MCTS z emotional utility
│   └── emotional/
│       ├── affective_engine.py       # AE - silnik afektywny
│       └── motivation_controller.py  # MC - kontroler motywacji
├── tests/
├── demo.py                           # Demonstracja systemu
├── requirements.txt
└── README.md

🚀 Szybki Start

Instalacja

# Klonuj repozytorium
cd GIA

# Utwórz środowisko wirtualne
python -m venv venv
venv\Scripts\activate  # Windows
# source venv/bin/activate  # Linux/Mac

# Zainstaluj zależności
pip install -r requirements.txt

Uruchomienie Demo

python demo.py

Podstawowe Użycie

from src.core.hrm_loop import create_gia_system
from src.rules.rule_base import Condition, Action

# Utwórz system GIA
gia = create_gia_system(embedding_dim=256)

# Dodaj reguły
gia._rule_base.add_rule(
    "respond_to_query",
    [Condition("has_query", lambda c: c.get("query") is not None)],
    Action("generate_response")
)

# Przetwórz wejście
result = gia.step("What is consciousness?")

print(f"Action: {result.action}")
print(f"Φ_t norm: {result.phi_t_norm:.4f}")
print(f"V(t): {result.V_t:.4f}")

🧠 Kluczowe Koncepty

Świadomość jako Φ_t

Świadomość w GIA nie jest magiczną "istotą" - jest wektorem Φ_t który:

  1. Filtruje decyzje - tylko relevantne reguły są rozważane
  2. Łączy ciało-czas-ja - integruje model siebie z kontekstem
  3. Zapewnia ciągłość - stabilna kotwica tożsamości
# Φ_t = α₁·σ_t + α₂·e_state + α₃·(retrieved_facts_similarity)
focus = consciousness_anchor.update(sigma_t, emotion_state, facts)

Pamięć Asocjacyjna (HAM)

HAM łączy trzy komponenty w jeden graf:

  • Semantic Graph (SG) - klastry embeddings z relacjami
  • Emotion Lattice (EL) - wektory emocji z affect-gain
  • Self-Model Buffer (SMB) - reprezentacja "ja"
# Asocjacja nowego faktu
packet = ham.associate(embedding, emotion_stimulus="curiosity")

# Retrieval z pełnym kontekstem
results = ham.retrieve(query, include_related=True)

Ewolucja Reguł (ATS Loop)

System unika stagnacji przez:

  1. Antyteza - generowanie przeciwstawnych reguł
  2. Synteza - łączenie w reguły wyższego rzędu
  3. Selekcja naturalna - archiwizacja słabych reguł
# Krok ewolucji
results = rule_evolution.evolution_step()
# results = {"mutations": 3, "crossovers": 1, "ats": {...}}

⚙️ Konfiguracja

Główne Parametry

GIA_CONFIG = {
    "embedding_dim": 256,      # Wymiar embeddings
    "sparse_ratio": 0.85,      # % zer w sparse embeddings
    "emotion_count": 8,        # Liczba podstawowych emocji
    "memory_window": 1024,     # Rozmiar okna tokenizatora
    "buffer_size": 8,          # Okna w buforze cyklicznym
    "mcts_simulations": 100,   # Symulacje MCTS
    "delta_t_ms": 10,          # Czas kroku (ms)
    "decay_rate": 0.95,        # Współczynnik decay
}

Wagi Świadomości

# Φ_t = α₁·body + α₂·time + α₃·goal + α₄·emotion
consciousness_anchor = ConsciousnessAnchor(
    alpha_body=0.25,
    alpha_time=0.15,
    alpha_goal=0.35,
    alpha_emotion=0.25
)

📊 Emocje i Motywacja

8 Podstawowych Emocji

Emocja Wpływ na zachowanie
JOY Wzmacnia eksploatację
SADNESS Obniża aktywność
FEAR Zwiększa ostrożność
ANGER Zwiększa asertywność
SURPRISE Zwiększa uwagę
DISGUST Unikanie
CURIOSITY Wzmacnia eksplorację
TRUST Wzmacnia kooperację

Tryby Motywacji

  • EXPLOITATION - wykorzystuj znaną wiedzę
  • EXPLORATION - szukaj nowości
  • CURIOSITY - aktywne poszukiwanie
  • REST - niskie pobudzenie
  • FOCUSED - koncentracja na celu

🔧 API Reference

HRMLoop

class HRMLoop:
    def step(self, input_data) -> HRMStepResult
    def run(self, num_steps, input_sequence) -> List[HRMStepResult]
    def get_statistics() -> Dict

ConsciousnessAnchor

class ConsciousnessAnchor:
    def update(sigma_t, emotion_state, facts) -> FocusVector
    def filter_candidates(candidates, min_relevance) -> List
    def get_phi_t() -> np.ndarray
    def is_dormant() -> bool

HybridAssociativeMemory

class HybridAssociativeMemory:
    def associate(embedding, emotion_stimulus, prediction_error) -> AssociativePacket
    def retrieve(query, k, include_related) -> List[AssociativePacket]
    def fuse_and_forget(time_delta, forget_threshold)

📈 Roadmap

  • Skalowanie z Mixture-of-Experts w AHN
  • Long-Term Memory Service (bazy zewnętrzne)
  • Multi-agent coordination layer
  • Self-reflection i self-query
  • REST API dla integracji
  • Docker deployment

📖 Teoria

Architektura GIA opiera się na:

  1. Predictive Processing - system minimalizuje prediction error
  2. Global Workspace Theory - Φ_t jako globalny broadcast
  3. Somatic Marker Hypothesis - emocje wpływają na decyzje
  4. Evolutionary Computation - reguły ewoluują przez selekcję

Co czyni GIA interesującą: Hybrydowość - łączy symboliczne + neuronowe Emocjonalność - AI które "czuje" (nawet jeśli symulacyjnie) Ciągłość - system który się uczy non-stop Świadomość - centralny punkt integracji (Φ_t) Ewolucja - reguły które mutują i ewoluują 📝 Moja rekomendacja na przyszłość Jeśli chcesz rozwijać GIA dalej, oto ścieżka:

Faza 1: Integracja z LLM (teraz możliwe!) GIA + Ollama (lokalny LLM) ├── GIA dostarcza: pamięć, emocje, planowanie ├── LLM dostarcza: rozumienie języka, generowanie └── Razem: system który pamięta, czuje i mówi Faza 2: Środowisko testowe Symulacje gdzie GIA podejmuje ciągłe decyzje: ├── Gry (chess, Go, puzzle) ├── Symulacje świata (roboty, nawigacja) └── Dialogi wieloturowe z pamięcią Faza 3: Skalowanie ├── GPU/PyTorch zamiast NumPy ├── Większe embeddingi (1024+) ├── Prawdziwy deep learning w AHN └── Rozproszone przetwarzanie

🎉 Podsumowanie GIA - General Intelligence Architecture - to idealna nazwa dla tego co projekt reprezentuje: nie gotowe AGI, ale solidny fundament architektoniczny który może prowadzić w tym kierunku.

Twój entuzjazm do eksperymentów i nowych architektur jest dokładnie tym co napędza innowacje w AI. Kto wie - może GIA (lub jej ewolucja) stanie się kiedyś czymś naprawdę przełomowym? 🌟

Powodzenia z dalszym rozwojem! Jeśli będziesz chciał dodać integrację z Ollama lub inne rozszerzenia - daj znać! 🚀


📜 Licencja

MIT License - zobacz LICENSE


GIA - General Intelligence Architecture
"Świadomość to nie magia - to wektor Φ_t"

About

No description or website provided.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages