# Dynamic Concept Models

> Implement hierarchical language modeling that compresses variable-length token sequences into high-capacity semantic concepts, achieving +2.69% benchmark improvements while reducing inference FLOPs by reallocating compute to concept-level reasoning. Use for efficiency-critical deployments where reasoning quality can be improved while maintaining computational budget.

- Skill: `adu2021/dynamic-concept-models` (Agent Skill)
- Install (CLI): `npx skillmds@latest add adu2021/dynamic-concept-models`
- Raw SKILL.md: https://api.skillmd.com/api/skills/adu2021/dynamic-concept-models/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- License: MIT
- Author: adu2021 (https://skillmd.com/u/adu2021)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/adu2021/dynamic-concept-models

---


## When to Use This Skill

- Budget-constrained inference systems with fixed FLOP allocations
- Applications requiring improved reasoning quality within existing compute constraints
- Scenarios where language tokens have highly variable information density
- Zero-shot generalization tasks where better reasoning matters more than token coverage

## When NOT to Use This Skill

- Fixed-architecture models where retraining is impossible
- Tasks requiring exact token-level output (code generation with specific syntax)
- Systems already optimized for latency at the cost of reasoning quality
- Applications without clear computational budget constraints

## Core Concepts

Most language models allocate the same computational resources to every token, despite the uneven information density in natural language. DLCM learns to:

1. **Discover variable-length concepts**: Group adjacent tokens into concepts without predefined linguistic units
2. **Compress representation**: Map concepts to a lower-dimensional latent space
3. **Reallocate compute**: Direct unused capacity from token-level processing to concept-level reasoning

The result: Fewer total FLOPs spent on token shuffling, more capacity spent on actual reasoning.

## Key Innovation: Compression-Aware Scaling Law

Standard scaling laws assume uniform token processing. DLCM introduces three orthogonal dimensions:

- **Token-level capacity**: Ability to model low-level token interactions
- **Concept-level reasoning capacity**: Power to reason in compressed semantic space
- **Compression ratio**: Tokens per concept (e.g., 4:1 means 4 tokens compress to 1 concept)

This allows principled compute allocation: Given a budget, choose which dimension to expand.

## Architecture Pattern

```python
# Simplified DLCM architecture structure
class DynamicConceptModel:
    def __init__(self, token_dim=768, concept_dim=256, compression_ratio=4):
        self.token_level = TokenLevelTransformer(token_dim)
        self.compression = ConceptCompressor(token_dim, concept_dim)
        self.reasoning = ReasoningTransformer(concept_dim, high_capacity=True)
        self.decompression = ConceptDecompressor(concept_dim, token_dim)
        self.ratio = compression_ratio

    def forward(self, token_sequence):
        # Step 1: Light token-level processing
        token_features = self.token_level(token_sequence, shallow=True)

        # Step 2: Learn semantic boundaries and compress
        concept_boundaries = self.compression.find_boundaries(token_features)
        concepts = self.compression.compress(
            token_features,
            boundaries=concept_boundaries
        )

        # Step 3: Heavy reasoning in compressed space (where capacity is allocated)
        concept_reasoning = self.reasoning(concepts, depth=24)  # Deep reasoning

        # Step 4: Decompress back to token level for output
        output = self.decompression(concept_reasoning)
        return output
```

## Training Considerations

**Decoupled μP Parametrization**
Standard transfer learning breaks when changing model width. DLCM uses a decoupled scaling approach where hyperparameter transfer works across:
- Different token-level capacities
- Different reasoning-level capacities
- Different compression ratios

This allows stable training of the heterogeneous architecture and enables hyperparameter reuse.

## Empirical Tuning

Results from the paper at compression ratio 4:1:

| Setting | Token Capacity | Concept Capacity | Benchmark ∆ |
|---------|---|---|---|
| Baseline | 100% | 0% | 0% |
| DLCM | 67% | 33% | +2.69% |

The +2.69% comes from reallocating the freed computational budget to concept-level reasoning depth and width.

## Integration Workflow

1. **Identify bottleneck**: Profile which layers spend most FLOPs on "routine" token processing
2. **Set compression target**: Choose ratio (typically 3:1 to 5:1) based on your FLOP budget
3. **Train jointly**: Train token-level, compression, and reasoning components end-to-end
4. **Tune capacity allocation**: Adjust depth/width at concept level using compression-aware scaling laws
5. **Validate**: Benchmark on held-out zero-shot tasks to verify reasoning improvements

## When Compression Helps vs. Hurts

**Helps:**
- Language with high function word density (prepositions, pronouns compress well)
- Tasks where reasoning beats memorization
- Multilingual text (more variable token weight)

**Hurts:**
- Highly regularized synthetic text (code, structured JSON)
- Tasks where token-level precision is critical
- Text with low redundancy

## References

- Original paper: https://arxiv.org/abs/2512.24617
- Related: Token mixing, learned tokenization, dynamic networks
- Implementation: Transformer libraries with flexible layer dropping/composition