██████╗ ██╗ █████╗
██╔════╝ ██║██╔══██╗
██║ ███╗██║███████║
██║ ██║██║██╔══██║
╚██████╔╝██║██║ ██║
╚═════╝ ╚═╝╚═╝ ╚═╝
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.
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
| 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) |
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
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
# 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.txtpython demo.pyfrom 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}")Świadomość w GIA nie jest magiczną "istotą" - jest wektorem Φ_t który:
- Filtruje decyzje - tylko relevantne reguły są rozważane
- Łączy ciało-czas-ja - integruje model siebie z kontekstem
- 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)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)System unika stagnacji przez:
- Antyteza - generowanie przeciwstawnych reguł
- Synteza - łączenie w reguły wyższego rzędu
- Selekcja naturalna - archiwizacja słabych reguł
# Krok ewolucji
results = rule_evolution.evolution_step()
# results = {"mutations": 3, "crossovers": 1, "ats": {...}}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
}# Φ_t = α₁·body + α₂·time + α₃·goal + α₄·emotion
consciousness_anchor = ConsciousnessAnchor(
alpha_body=0.25,
alpha_time=0.15,
alpha_goal=0.35,
alpha_emotion=0.25
)| 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ę |
- EXPLOITATION - wykorzystuj znaną wiedzę
- EXPLORATION - szukaj nowości
- CURIOSITY - aktywne poszukiwanie
- REST - niskie pobudzenie
- FOCUSED - koncentracja na celu
class HRMLoop:
def step(self, input_data) -> HRMStepResult
def run(self, num_steps, input_sequence) -> List[HRMStepResult]
def get_statistics() -> Dictclass 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() -> boolclass 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)- 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
Architektura GIA opiera się na:
- Predictive Processing - system minimalizuje prediction error
- Global Workspace Theory - Φ_t jako globalny broadcast
- Somatic Marker Hypothesis - emocje wpływają na decyzje
- 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ć! 🚀
MIT License - zobacz LICENSE
GIA - General Intelligence Architecture
"Świadomość to nie magia - to wektor Φ_t"