LLM Training Demo

What This Demo Shows

This dashboard demonstrates GenesisNode learning language capabilities from scratch -- no gradient descent, no matrix multiplication, no backpropagation. Instead of the dense linear algebra that powers transformers and traditional neural networks, GenesisNode builds a sparse graph of token-based nodes that fire or don't fire based on simple threshold decisions. Intelligence emerges from the topology of this graph and the pattern of binary selections, not from precise numerical computation.

You can watch in real time as the system:

• Learns word associations (e.g., "dog" → "cat", "hot" → "cold") through genetic evolution and credit assignment
• Builds chain reasoning paths that allow multi-hop inference (if A→B and B→C, infer A→C)
• Develops an internal knowledge graph with specialized node roles, weighted connections, and tiered memory

The system has been validated through 10 capability levels, from basic word associations up to common sense reasoning, reading comprehension, and factual knowledge retrieval -- all without a single gradient computation.

---

How GenesisNode Learns

GenesisNode is not a neural network. It is a self-organizing graph architecture inspired by neuromorphic computing and genetic algorithms.

The Node

The fundamental unit is a Node -- a simple object that stores a token_id (a string like "dog" or "cold"), maintains weighted connections to other nodes, and has a firing threshold. When a signal arrives, the node either fires or stays silent. That binary decision is the only primitive operation. There are no weight matrices, no activation functions, no layers.

Graph Routing

When you query the system with a word, it performs a graph walk: the input token activates its corresponding node, which propagates signal along weighted connections to neighboring nodes. The node at the end of the strongest path becomes the output prediction. Routing is a sequence of dictionary lookups along connection edges -- O(connections) per hop, not O(parameters).

Scoring and Credit Assignment

After each prediction, the system scores the result (correct = 1.0, incorrect = 0.0). Credit flows backward along the firing chain -- the sequence of nodes that fired to produce the output. Nodes closer to the output get the full score; nodes further back get a decayed fraction. Over many iterations, this strengthens correct pathways and weakens incorrect ones.

An emotional scoring system provides higher-level control signals:

• Confidence (high recent scores) -- stay in responding mode, use established pathways
• Frustration (consecutive low scores) -- switch to learning mode, spawn new nodes, try new routes
• Surprise (predicted score far from actual) -- trigger restructuring

Genetic Evolution

Network topology evolves through a genetic algorithm. Each epoch, the system applies mutations: spawning new connections between nodes, adjusting firing thresholds, growing new nodes when progress stalls. After mutation, the system benchmarks against its training data. Improvements are kept; regressions are reverted. Mutation rates are adaptive -- they increase when the system is stuck and decrease when accuracy is improving.

Scaler Nodes and Level Isolation

A key architectural innovation is the scaler node: per-level proxy nodes that absorb all level-specific learning while leaving prior-level token nodes untouched. This solves catastrophic forgetting -- the system can learn Level 10 common sense reasoning without degrading Level 1 word associations. Each level's scaler nodes use isolated context tags (e.g., seq_pos:, rel:, qa:, cs:) to prevent cross-level interference.

Three-Tier Memory

Nodes are organized into three tiers:

• Hot (~500-1,000 nodes): actively processing, instant access
• Warm (~5,000-10,000 nodes): loaded and ready, promoted to hot on activation
• Cold (everything else): stored on disk, pulled in on demand

Only about 1% of the network is active at any moment. This sparse activation means inference cost scales with problem complexity, not model size.

---

Using the Dashboard

Training Controls (Top Bar)

The top bar contains all controls for configuring and running a training session:

• Approach -- a dropdown selector to choose the training approach (see Training Approaches below)
• Epochs -- how many training cycles to run (default: 200). Each epoch includes evaluation, focused training on unmastered pairs, reinforcement of mastered pairs, and genetic evolution
• Nodes -- the initial network size (default: 5,000). The network grows dynamically during training when progress plateaus
• Start -- launches the training run in a background thread. The button disables while training is active
• Stop -- gracefully halts the current run. Progress up to that point is preserved

A status indicator in the top-right corner shows the current state: Idle, Training (with a pulsing green dot and epoch counter), Complete, or Error.

Left Panel

The left panel contains five cards that update in real time during training:

Accuracy Chart

A line chart tracking two metrics over epochs:

• Accuracy % (blue line): exact-match accuracy across all training pairs. This is the primary metric -- it shows how often the system's top prediction exactly matches the expected output.
• Top-5 % (green line): whether the correct answer appears anywhere in the system's top 5 predictions. This is typically higher than exact match and reaches 100% earlier.

Average Score Chart

Tracks the average scoring signal over epochs. A rising score indicates the network is strengthening correct pathways. Plateaus often precede breakthroughs when genetic evolution discovers a new shortcut connection.

Current Stats Table

A live summary of the training state:

• Epoch: current / total
• Best Accuracy and Best Top-5: high-water marks across the run
• Current Accuracy: this epoch's exact-match rate
• Nodes: total node count (grows dynamically)
• Groups: how many node clusters have formed
• Connections: total weighted edges in the graph
• Links: secondary reference edges
• Epoch Time: milliseconds per epoch

Inference Panel

Test the trained model interactively. Type a word into the input field and click "Infer" to see:

• The top predictions ranked by connection strength, displayed as horizontal bars
• The confidence score for each prediction
• The firing chain -- a visual flow diagram showing exactly which nodes fired and what connections were traversed to produce the prediction. This is the model's reasoning trace, fully transparent

Run History

A table of all previous training runs in this session, showing approach, epochs, and final accuracy. Click a run to review its stats.

Right Panel

The right panel displays a live network graph -- a force-directed D3.js visualization of the node topology:

Nodes are colored by role:

• Blue (Hub): high-connectivity nodes that route many signals
• Green (Member): standard nodes within a cluster
• Orange (Input): nodes that frequently receive input signals
• Purple (Output): nodes that frequently produce outputs
• Gray (General): unspecialized nodes

Edges show connections (solid lines) and links (dashed lines) between nodes. Edge thickness reflects connection weight.

Interactive controls in the toolbar:

• Max Nodes slider: limits how many nodes are rendered (for performance)
• Link Force slider: adjusts the spring tension between connected nodes
• Charge slider: controls repulsion between nodes (spread vs. clustering)
• Reset View: re-centers the graph

Hover over any node to see a tooltip with its token ID, role, tier, fire count, connection count, threshold, and maturity.

During inference, activated nodes pulse along the firing chain, letting you visually trace the reasoning path through the graph.

---

Training Approaches

word_assoc (Word Associations -- 75 pairs)

The foundational training approach. Trains on 78 curated word-association pairs spanning semantic categories: animals ("dog" → "cat"), antonyms ("hot" → "cold"), professions ("doctor" → "hospital"), colors ("sky" → "blue"), and more.

This demonstrates the core learning loop: present an input word, get the network's prediction, score the result, strengthen or weaken the firing chain, and evolve the topology. It is the same approach used for Level 1 validation and typically reaches 95%+ accuracy within 200 epochs.

word_assoc_scale (Scaled Associations -- configurable)

An extended version that generates a larger set of association pairs using a semantic hash encoder. The pair count is configurable (default: 372). This approach tests whether the architecture scales beyond a small, hand-curated dataset. The learning dynamics are the same as word_assoc, but with a larger vocabulary and more diverse relationships.

word_chains (Chain Reasoning)

Trains on the same 75 association pairs as word_assoc but additionally evaluates multi-hop chain inference. After learning direct associations (A→B, B→C), the system is tested on transitive chains (A→C). This demonstrates Level 2 capabilities: the ability to compose learned knowledge into novel inferences without explicit training on those chains.

---

What to Expect

Typical Training Progression

Timing

• Each epoch takes 5-50ms depending on network size and number of active training pairs
• A full 200-epoch word_assoc run completes in 5-15 seconds
• Inference (single query) takes 15-35 microseconds -- orders of magnitude faster than transformer inference

Testing Inference

After training completes, use the Inference Panel to test individual words. Try:

• Words from the training set: "dog", "hot", "doctor", "king" -- should return the correct association
• Multi-hop queries: if "dog" → "cat" and "cat" → "mouse" are learned, querying with chain reasoning can yield transitive results

The firing chain visualization shows you exactly why the model predicted what it did -- which nodes fired, what connections were traversed, and with what weights. This level of interpretability is a structural advantage over black-box neural networks.

---

Capability Levels

GenesisNode has been validated through 10 capability levels, each introducing a fundamentally new mechanism:

Level	Capability	Key Result
L1	Word Associations	98.7% exact match, 78 pairs, 18 us/call
L2	Multi-Hop Inference	98.4% 2-hop, 95.0% 3-hop chains
L3	Multi-Token Input (Context Fusion)	100% exact, 100% disambiguation
L4	Sequence Completion	99.7% next-token exact, 100% patterns
L5	Multi-Token Output (Generation)	85.1% exact sequence, 95.2% BLEU-1
L6	Part-of-Speech Tagging	100% POS accuracy, 70.7% BLiMP grammaticality
L7	Factual Knowledge Retrieval	100% triple exact, 260 triples, 18 relations
L8	Coreference Resolution	100% gender, 100% coref exact, 181 pairs
L9	Reading Comprehension	80.7% QA exact, 84.6% F1, 96.0% yes/no
L10	Common Sense Reasoning	99.6% CS exact, 100% PIQA, 90.9% CommonsenseQA

Each level is additive -- Level 10 still passes all Level 1 tests. The scaler node architecture ensures zero cross-level interference: Level 1 accuracy remains 98.7% after training through all 10 levels.

Training is also cumulative -- each level's data includes all prior levels, and the system must learn new capabilities without forgetting old ones. The total system at Level 10 comprises 4,526 nodes handling a vocabulary of thousands of tokens, with inference at 28 microseconds per call.

---

How It Compares to Transformers

Every capability level includes a corresponding transformer baseline -- a standard PyTorch transformer trained on the exact same data, solving the exact same task. This provides an apples-to-apples comparison.

Where GenesisNode Wins

• Inference speed: 10-600x faster. GenesisNode's graph routing (15-35 us/call) dramatically outperforms transformer forward passes (1,200-9,000 us/call). Sparse activation means only relevant nodes participate.
• Knowledge retention: GenesisNode retains 97-100% of prior-level accuracy when learning new levels. Transformers typically degrade to 91-96% on earlier tasks -- the well-known catastrophic forgetting problem.
• Multi-hop reasoning: GenesisNode's graph structure makes transitive inference (A→B→C) a natural operation. It achieves 98.4% on 2-hop and 95.0% on 3-hop chains, vs. 73-85% for transformers.
• Interpretability: Every prediction comes with a full firing chain trace -- you can see exactly which nodes fired, which connections were used, and with what weights. Transformer hidden states are opaque.
• Sample efficiency: GenesisNode learns from tens to hundreds of examples. Transformers need orders of magnitude more data for equivalent tasks.

Where Transformers Win

• BLiMP grammaticality: Transformers achieve 100% on minimal-pair grammaticality judgments (vs. 70.7% for GenesisNode), leveraging their ability to learn position-dependent patterns globally.
• Constrained generation: On some constrained generation tasks, transformers achieve 100% vs. GenesisNode's 93.9%.
• Raw benchmark scores at scale: On large standardized benchmarks with thousands of examples, transformers' dense computation and global attention remain dominant. GenesisNode's strength is on smaller, interpretable, efficiency-critical tasks.

The Fundamental Difference

Transformers learn by computing gradients over millions of parameters using backpropagation -- calculus-driven optimization. GenesisNode learns by evolving a graph topology through variation and selection -- the same mechanism biology uses. The training process and the inference process are the same operation: graph routing. There is no separate "training algorithm" that differs from the "inference algorithm."