F.R.I.D.A.Y - AI with Dynamic Neural Network

FRIDAY is a revolutionary AI assistant with a dynamic neural network that learns and grows continuously. Inspired by TRM (Tiny Recursive Model), FRIDAY combines recursive reasoning with transparent, editable neurons.

🌟 Key Features

🧠 TRM-Inspired Architecture

Recursive Reasoning - Thinks multiple times, improving answers iteratively
Hierarchical Processing - Abstract (z_H) + Detail (z_L) neurons
Adaptive Halting - Knows when answer is good enough
7M parameters equivalent - But dynamic and growing!

🎯 Dynamic Neural Network

Not statically trained - Add neurons anytime, no retraining needed
Transparent - Every neuron has visible content and meaning
Editable - Add, remove, or modify knowledge easily
Grows continuously - Learns from every interaction

🚀 Advanced Learning

Autonomous TRM Learning - Learns independently using TRM logic
Self-Evaluation - Rates its own responses (0-5.0)
Adaptive Learning - Learns more from good responses
Teacher Learning - Can learn from other AI models (Ollama, etc.)
Hebbian Learning - Strengthens connections between co-activated neurons
Meta-Learning - Learns how to learn, optimizes strategies

📊 3D Visualization

Real-time 3D viewer - See neurons and synapses in action
Activation visualization - Watch neurons light up during queries
Interactive - Explore the neural network

🚀 Quick Start

Installation

# Clone repository
git clone https://github.com/yourusername/F.R.I.D.A.Y.git
cd F.R.I.D.A.Y

# Install dependencies
pip install -r requirements.txt

# Initialize database
python scripts/init_brain.py

First Test

# Test TRM architecture
python scripts/test_trm_architecture.py

Start Web Interface

# Start FRIDAY server
python friday.py

Open http://localhost:5000 to see the 3D neural network!

📁 Project Structure

F.R.I.D.A.Y/
├── friday.py                    # Main entry point
├── requirements.txt             # Dependencies
│
├── src/                         # Core system
│   ├── brain.py                 # Neural database
│   ├── query_engine.py          # Query processing
│   ├── trm_brain.py            # TRM architecture
│   ├── autonomous_trm_learner.py # Autonomous learning with TRM
│   ├── text_generator.py       # Response generation
│   ├── response_evaluator.py   # Self-evaluation
│   ├── hebbian_learning.py     # Hebbian learning
│   ├── model_teacher.py        # Learn from other models
│   └── server.py               # Web server
│
├── scripts/                     # Utility scripts
│   ├── init_brain.py           # Initialize database
│   ├── download_lmsys_dataset.py # Download LMSYS dataset
│   ├── train_with_lmsys_dataset.py # Train with LMSYS
│   ├── assimilate_knowledge.py # Learn from models
│   ├── learn_from_teacher.py   # Teacher learning
│   ├── autonomous_trm_training.py # Autonomous TRM learning
│   ├── demo_autonomous_learning.py # Quick demo
│   ├── test_trm_architecture.py # Test TRM
│   ├── test_self_learning.py   # Test self-learning
│   └── README.md               # Scripts documentation
│
├── static/                      # Web interface
│   └── viewer.html             # 3D viewer
│
├── data/                        # Data storage
│   └── friday.db               # Neural database
│
├── docs/                        # Documentation
│   ├── TRM_ANALYSIS.md         # TRM architecture analysis
│   ├── FRIDAY_TRM_HYBRID.md    # Hybrid architecture
│   ├── GENERATION_SYSTEM.md    # Text generation
│   ├── SELF_LEARNING_ARCHITECTURE.md
│   ├── LEARNING_FROM_MODELS.md
│   └── README.md               # Docs index
│
└── model/                       # AI models
    └── TinyRecursiveModels/    # TRM reference

🧠 How It Works

0. Autonomous TRM Learning ⭐ NEW

FRIDAY lernt selbstständig mit TRM-Logik zur richtigen KI zu werden:

# FRIDAY testet sich selbst
result = trm_processor.process(question, question_type)
score = result['score']

# Autonomous learning decision
if score < 3.5:
    # Schlecht → Lernen!
    # 1. Analysiere Fehler
    failure = analyze_failure(question, result)
    
    # 2. Hole Wissen vom Teacher
    teacher_answer = teacher.query_model(question)
    
    # 3. Extrahiere Reasoning
    reasoning = extract_reasoning(question, teacher_answer)
    
    # 4. Erstelle Neuronen
    neurons = create_learning_neurons(answer, reasoning)
    
    # 5. Verbinde mit Wissen
    connect_to_existing(neurons, question)
    
elif score >= 4.5:
    # Exzellent → Gemeistert!
    record_mastery(question, result)

# Meta-Learning: Lerne aus Mustern
if improvement_stalled:
    optimize_parameters_from_patterns()

Kernprinzipien:

✅ TRM Recursive Reasoning - Denkt mehrfach nach
✅ Self-Evaluation - Bewertet sich selbst
✅ Autonomous Learning - Lernt automatisch bei Fehlern
✅ Pattern Recognition - Erkennt erfolgreiche Muster
✅ Meta-Learning - Lernt wie man lernt

1. TRM-Inspired Recursive Reasoning

# FRIDAY thinks recursively (like TRM)
for h_cycle in range(3):  # High-level cycles
    for l_cycle in range(4):  # Low-level cycles
        z_L = update_details(z_L, z_H + input)
    z_H = update_abstract(z_H, z_L)
    
    response = generate(z_H, z_L)
    score = self_evaluate(response)
    
    if score >= 4.5:  # Good enough!
        break

2. Dynamic Neurons (Not Static Weights!)

# TRM: Static weights
weights = torch.Tensor([...])  # Fixed, needs retraining

# FRIDAY: Dynamic neurons
neuron = brain.create_neuron(
    content="Python is a programming language",
    tags=['Programming', 'Python']
)
# No retraining needed!

3. Self-Learning

# FRIDAY evaluates its own responses
evaluation = evaluator.evaluate_response(response, query)
# Score: 4.2/5.0

# Learns adaptively
if score >= 4.0:
    learning_strength = 1.5  # Strong learning
elif score < 2.0:
    learning_strength = 0.5  # Weak learning

🎯 Usage

Chat with FRIDAY

from src.brain import Brain
from src.query_engine import QueryEngine
from src.hebbian_learning import HebbianLearner

brain = Brain("data/friday.db")
hebbian = HebbianLearner(brain)
query_engine = QueryEngine(brain, hebbian)

result = query_engine.query("Was ist Python?")
print(result['response'])
# Output: "Python ist ein System, das programming, syntax verwendet."
print(f"Score: {result['evaluation']['total_score']}/5.0")
# Output: Score: 4.8/5.0

Learn from Teacher Model

# Install Ollama first: https://ollama.ai
ollama pull qwen2.5:3b

# Train FRIDAY
python scripts/learn_from_teacher.py

Add Knowledge Manually

# Add a new neuron
neuron_id = brain.create_neuron(
    neuron_type='hidden',
    x=0.0, y=0.0, z=0.0,
    content="Machine Learning is a subset of AI",
    semantic_tags=['AI', 'Machine Learning', 'Concept']
)

# FRIDAY now knows this!

📊 Testing

Test TRM Architecture

python scripts/test_trm_architecture.py

Output:

🧠 TRM-Style Processing
   H_cycles: 3
   L_cycles: 4
   z_H neurons: 71
   z_L neurons: 26
   
🔄 H-Cycle 1/3
   Score: 4.8/5.0
   ✅ Halted: Score >= 4.5

Test Self-Learning

python scripts/test_self_learning.py

Autonomous TRM Learning

# Quick demo
python scripts/demo_autonomous_learning.py

# Full training
python scripts/autonomous_trm_training.py

LMSYS-Chat-1M Training ⭐ NEW

# Download dataset
python scripts/download_lmsys_dataset.py

# Train with real conversations
python scripts/train_with_lmsys_dataset.py

Test Realistic Queries

python scripts/test_realistic_queries.py

🔧 Configuration

Database Location

Default: data/friday.db

Change in code:

brain = Brain("path/to/your/database.db")

TRM Parameters

Adjust in src/trm_brain.py:

self.H_cycles = 3  # High-level cycles
self.L_cycles = 4  # Low-level cycles
self.halt_threshold = 4.5  # When to stop

📈 Performance

Comparison with TRM

Feature	TRM (Original)	FRIDAY + TRM
Parameters	7M (static)	~100 neurons (dynamic)
Training	3 days, 4x H100	Continuous, CPU
Knowledge	Fixed (puzzles)	Growing (any topic)
Editable	No (retrain needed)	Yes (add/remove neurons)
Transparent	No (black box)	Yes (see all neurons)
Reasoning	Recursive ✓	Recursive ✓

Scores

Typical response scores: 4.5-5.0/5.0

Evaluation criteria:

Length (optimal 50-300 chars)
Relevance (keywords from query)
Grammar (proper structure)
Neuron usage (knowledge utilization)
Type match (fits question type)
Completeness (full answer)

📚 Documentation

Getting Started

Architecture

Learning

Complete Index

Documentation Index

🎯 Roadmap

Current (v2.1)

✅ TRM-inspired architecture
✅ Dynamic neurons
✅ Self-evaluation
✅ Recursive reasoning
✅ Teacher learning
✅ Autonomous TRM Learning ⭐ NEW
✅ Meta-Learning ⭐ NEW
✅ Pattern Recognition ⭐ NEW
✅ LMSYS-Chat-1M Training ⭐ NEW
✅ Real Conversation Data ⭐ NEW

Next (v2.2)

Multi-Teacher Learning (learn from multiple models)
Curriculum Learning (structured learning path)
Active Learning (self-select questions)
Multi-language support
Voice interface

Future (v3.0)

Distributed neurons (multiple databases)
Collaborative learning (multiple FRIDAYs)
Advanced reasoning (symbolic + neural)
Autonomous goal-setting

🤝 Contributing

Contributions welcome!

Fork the repository
Create feature branch (git checkout -b feature/amazing)
Commit changes (git commit -m 'Add amazing feature')
Push to branch (git push origin feature/amazing)
Open Pull Request

📄 License

MIT License - See LICENSE file

🙏 Acknowledgments

TRM - Inspired by Tiny Recursive Model architecture
Ollama - Local LLM support
Three.js - 3D visualization
SQLite - Neural database

📧 Contact

Questions? Open an issue on GitHub!

FRIDAY - The AI that thinks recursively and grows continuously! 🧠🚀

🎉 NEW: LMSYS-Chat-1M Training

FRIDAY kann jetzt mit 1M+ echten Konversationen aus der Chatbot Arena trainiert werden!

Quick Start:

# 1. Download dataset
python scripts/download_lmsys_dataset.py

# 2. Train FRIDAY
python scripts/train_with_lmsys_dataset.py

Ergebnis:

✅ 1000+ echte Konversationen
✅ 2800+ Q&A Paare
✅ 300+ Neuronen aus echten Daten
✅ Score 4.6/5.0 nach Training
✅ Autonomous TRM Learning

Mehr Info: LMSYS Quick Start | Full Docs

Name		Name	Last commit message	Last commit date
.kiro/specs/friday-neustart		.kiro/specs/friday-neustart
data		data
docs		docs
scripts		scripts
src		src
static		static
.gitignore		.gitignore
LMSYS_QUICKSTART.md		LMSYS_QUICKSTART.md
NEW_FILES_OVERVIEW.md		NEW_FILES_OVERVIEW.md
README.md		README.md
SETUP_GUIDE.md		SETUP_GUIDE.md
TRAINING_SUMMARY.md		TRAINING_SUMMARY.md
friday.py		friday.py
pyproject.toml		pyproject.toml
requirements.txt		requirements.txt
uv.lock		uv.lock

Latest commit

History

Folders and files

Repository files navigation