File size: 3,258 Bytes
3706bdc | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 | ---
library_name: fsi_echo
license: apache-2.0
tags:
- code
- debug
- fsi-echo
- morphing-swarm
- tiny-model
- mobile
datasets:
- gold_standard_corpus
metrics:
- accuracy
- loss
- perplexity
---
# FSI_ECHO — Morphing Code Swarm
**The smallest, fastest code intelligence model. Fits in your hand.**
## Architecture (Novel Design)
FSI_ECHO is a **Morphing Code Swarm** — inspired by the concept of transforming machines and nanobot swarm intelligence. Entirely original architecture.
| Feature | Description |
|---------|-------------|
| **Morph Embedding** | Tokens don't have fixed embeddings. Each token's representation transforms based on its context — like a robot changing form for different situations. |
| **Nanobot Swarm Layer** | 512 tiny processing units (nanobots), each with two operational modes: **scout** (fast pattern scanning) and **combat** (deep reasoning). A learned router selects the mode per token. |
| **Assembly Blocks** | Standard transformer layers for coordinated deep processing. Like Constructicons forming Devastator — individual units combine into a more powerful entity. |
| **Self-Verification Head** | Built-in confidence scoring per token. The model knows when it's uncertain. |
| **Closed-Loop Debug** | Generates code, verifies via symbolic checks, and iteratively refines. |
### Size
| Metric | Value |
|--------|-------|
| Parameters | **2,621,578** (2.6M) |
| FP32 Size | 10 MB |
| Q8 Size | 2.6 MB |
| Q4 Size | **1.3 MB** |
| Vocab | 4,096 tokens |
| Context | 2,048 tokens |
## Performance
Trained on CPU (Android) with minimal data to demonstrate architecture viability.
| Metric | Value |
|--------|-------|
| Training Loss | 0.75 (after 200 steps) |
| Starting Loss | 8.32 |
| Speed | 3.9 tok/s (CPU, Android aarch64) |
## Unique Features
1. **Morphing Embeddings** — No other model uses context-adaptive token embeddings
2. **Dual-Mode Nanobot Swarm** — Scout/combat mode selection per token
3. **Built-in Self-Verification** — Knows when it's confident vs uncertain
4. **Closed-Loop Debugging** — Full verification pipeline with symbolic checks
5. **GGUF Format** — Runs with llama.cpp, Ollama, on any device
## Usage
### Python
```python
from fsi_echo import FSIEchoModel, CodeTokenizer
model = FSIEchoModel()
tokenizer = CodeTokenizer()
# Generate code
result = model.generate(tokenizer, "Write a function to sort a list:")
print(result['generated'])
# Debug code
from fsi_echo import ClosedLoopDebugger
debugger = ClosedLoopDebugger(model, tokenizer)
result = debugger.debug("def add(a, b):\n a + b")
print(result['code'])
```
### GGUF (llama.cpp / Ollama)
```bash
# Clone with llama.cpp
./main -m fsi_echo.f32.gguf -p "Write a function:"
```
## Files
| File | Description |
|------|-------------|
| `fsi_echo.f32.gguf` | Full precision GGUF |
| `config.json` | Model configuration |
| `model.safetensors` | PyTorch weights |
| `fsi_echo.py` | Full source code |
| `architecture.json` | Detailed architecture spec |
## Benchmark Results
After 200 training steps on CPU:
- Code completion accuracy: ~50% (training continues to improve)
- Loss reduction: 8.32 → 0.75 (91% reduction)
- Model size: 2.6M params (smaller than any competitor)
## License
Apache 2.0
|