batteryphil/thalamic-bloom

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

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.

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.