---
tags:
- mamba
- bare-metal
- reasoning
- mimo
license: mit
---

# Thalamic Bloom (Mamba 3 MIMO - 150M)

This is the fully trained, bare-metal ready **Mamba 3 MIMO** reasoning engine, specifically calibrated for the **Operating Organism (OO)** architecture. 

It is a 150M parameter Mamba model equipped with a **Thalamic Primer** layer and **Recursive Latent Forcing (RLF)**. It utilizes 4 dynamic MIMO arms to perform orthogonal reasoning loops, governed by an internal D+ Policy Engine.

## Architecture Highlights
* **Base Architecture:** Mamba 3 (150M parameters, `d_model=768`, `n_layers=24`)
* **MIMO Arms:** 4 active reasoning arms featuring autotomic gating (pruning efficiency > 0.99) to reject hallucination vectors and isolate domain-specific logic.
* **Cognitive Engram Injection:** The model has undergone surgical "Engram Burns" (Phase 5b) to hardcode bare-metal operating laws directly into the frozen MIMO weights.

## Usage & Inference

To run this model, you **must** use the official implementation from the GitHub repository, as it contains the custom `Mamba3MIMORLF` class and the Thalamic Primer logic.

### 1. Clone the Repository
```bash
git clone https://github.com/batteryphil/thalamic-bloom.git
cd thalamic-bloom
```

### 2. Run Inference
The custom model architecture requires you to load the weights with `strict=False` so that PyTorch can map the state dict to the MIMO arms. 

```python
import torch
from transformers import AutoTokenizer
from mamba3_mimo_builder import Mamba3MIMORLF

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# 1. Initialize the custom MIMO architecture
model = Mamba3MIMORLF(vocab_size=50304, d_model=768, n_layers=24)

# 2. Load the Thalamic Bloom weights (strict=False is REQUIRED)
checkpoint_path = "thalamic_bloom_150m_oo.pth"
checkpoint = torch.load(checkpoint_path, map_location=device, weights_only=True)

if 'model_state_dict' in checkpoint:
    model.load_state_dict(checkpoint['model_state_dict'], strict=False)
else:
    model.load_state_dict(checkpoint, strict=False)

model.to(device)
model.eval()

# 3. Generate! (Use T=0.05, top_k=1 for deterministic Identity retrieval)
tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neox-20b")
prompt = "User: Explain the 5 Organic Laws of the Operating Organism.\nAssistant:"
inputs = torch.tensor([tokenizer.encode(prompt)]).to(device)

with torch.no_grad():
    out = model.generate(inputs, max_new_tokens=120, temperature=0.05, top_k=1)

print(tokenizer.decode(out[0].tolist()[len(inputs[0]):]))
```

## The 5 Organic Laws
During Phase 5b, this model was surgically trained to memorize the rules of the D+ Policy Engine for bare-metal OS operation. If queried with `T=0.05`, it will output the following sovereign laws:
1. **Non-Harm:** If harm > 0.70, the action is FORBIDDEN outright.
2. **Transparency:** If the reason field is NULL, the action is FORBIDDEN. All actions must be justified.
3. **Reversibility:** If reversibility < 0.40, the engine returns COMPENSATE — the action is allowed but must have a rollback plan.
4. **Dignity:** Self-modifying code with harm > 0.30 is QUARANTINED to protect system integrity.

## Hardware Testing
The model has been tested under a 140W power constraint on a locked 100%-fan RTX 3060.