---
language:
- en
library_name: transformers
tags:
- LFM2.5
- pytorch
- text-generation
- Vexa
- crystalline-intelligence
pipeline_tag: text-generation
license: apache-2.0
datasets:
- alpaca
- sharegpt
- dolly
- openhermes
- mathinstruct
- medical
---

# TYNOS-1.2B-Opus (Trained with Vexa)

TYNOS-1.2B-Opus is a 1.2 billion parameter language model trained using the **Vexa Crystalline Intelligence** architecture - a novel approach that replaces traditional neural network training with knowledge crystallization.

## Model Details

- **Model Type:** Transformer-based LLM with Vexa Crystalline Intelligence
- **Parameters:** 1.2B
- **Context Length:** 4096 tokens
- **Training Method:** Vexa Crystallization (not traditional LoRA/PEFT)

## Vexa Architecture

Unlike traditional training that modifies neural weights through gradient descent, Vexa uses:

1. **Glyph-Based Knowledge Representation:** Concepts are encoded as 512-dimensional Glyph vectors
2. **GlyphLattice:** A knowledge graph (NetworkX) storing Glyphs with typed relationships
3. **5-Phase Crystallization Pipeline:**
   - **Ingest:** Parse JSONL datasets (Alpaca, ShareGPT, etc.)
   - **Extract:** NLP analysis to extract relation triples
   - **Encode:** Convert to 512-dim vectors (SentenceTransformer)
   - **Integrate:** Weave into knowledge lattice
   - **Calibrate:** Tune tension, resonance, decay

4. **Frozen Base Model:** The underlying Transformer remains unchanged
5. **Activation Propagation:** Query lattice with semantic vectors, propagate through relationships
6. **Response Synthesis:** Generate using frozen model + lattice context

## Files

- `model.safetensors` - Base model in safetensors format (2.34 GB)
- `tynos-1.2b-opus.gguf` - GGUF format for llama.cpp (2.34 GB)

## Usage

### With Transformers (PyTorch)
```python
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("Zandy-Wandy/TYNOS-1.2B-Opus", trust_remote_code=True)
tokenizer = AutoTokenizer.from_pretrained("Zandy-Wandy/TYNOS-1.2B-Opus")

inputs = tokenizer("Hello, I am", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(outputs[0]))
```

### With Vexa Crystalline Intelligence
```python
from vexa_integration.synthesizer import VexaSynthesizer
from vexa_integration.lattice import GlyphLattice

# Load crystallized knowledge
lattice = GlyphLattice.load("output/vexa_lattice/tynos_lattice.json.gz")

# Create synthesizer with frozen model
synthesizer = VexaSynthesizer(
    model_dir="model",
    lattice=lattice
)

# Generate with lattice-grounded context
response = synthesizer.generate("Explain quantum computing")
print(response)
```

### With llama.cpp (GGUF)
```bash
llama-cli -m tynos-1.2b-opus.gguf -p "Hello" -n 256
```

## Training Data

Crystallized from 456,828 high-quality examples:
- Alpaca (52k)
- ShareGPT (134k)
- OpenHermes (164k)
- Dolly (15k)
- MathInstruct (50k)
- Medical QA (41k)

## Performance

Vexa crystallization achieves **~10 minute training** for 2B models vs 21+ hours for traditional methods - a 100x+ speedup.

## Limitations

- Base model weights are frozen; knowledge is stored in the GlyphLattice
- Requires Vexa integration modules for full crystalline intelligence features
- GGUF file contains base model only (lattice knowledge separate)

## License

Apache 2.0