| --- |
| 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. |
|
|
