Phase 2.2: Embedding Integration

dlm/core/ircp/
├── __init__.py
├── attention.py          # InverseAttentionMechanism
├── measure.py            # InverseRingTransform
├── base_models.py        # ICPBaseModel, ModelRegistry
└── topology.py           # RingTopology

from dlm.core.ircp import InverseAttentionMechanism
from dlm.core.ircp import InverseRingTransform

assert InverseAttentionMechanism is not None

# packages/dlm/core/embeddings.py

from dlm.response.embedding_provider import BaseEmbeddingProvider
from dlm.core.ircp import InverseAttentionMechanism, InverseRingTransform

class IRCPCustomHeads(nn.Module):
    """Custom IRCP prediction heads"""
    # Port from IRCP
    ...

class IRCPEmbedder(BaseEmbeddingProvider):
    """
    IRCP-based embedding provider with caching and batch processing.

    Extends BaseEmbeddingProvider to add:
    - Automatic caching (from BaseEmbeddingProvider)
    - Batch processing (from BaseEmbeddingProvider)
    - IRCP-specific coordinate prediction
    - Response pattern prediction
    - Confidence estimation
    """

    def __init__(
        self,
        model_name: str = "sentence-transformers/all-MiniLM-L6-v2",
        cache_capacity: int = 512,
        cache_ttl: float = 3600,
        batch_size: int = 32,
        enable_caching: bool = True,
        **ircp_config
    ):
        super().__init__(cache_capacity, cache_ttl, batch_size, enable_caching)

        # Load IRCP model
        self.model = self._load_ircp_model(model_name, **ircp_config)

    def _generate_embedding_impl(self, text: str) -> np.ndarray:
        """Generate single embedding (called by BaseEmbeddingProvider)"""
        with torch.no_grad():
            emb = self.model.encode(text)
        return emb

    def _generate_embeddings_batch_impl(self, texts: List[str]) -> List[np.ndarray]:
        """Generate batch embeddings (optimized)"""
        with torch.no_grad():
            embs = self.model.encode_batch(texts)
        return embs

    def predict_coordinates(
        self, text: Union[str, np.ndarray]
    ) -> np.ndarray:
        """Predict IRCP coordinates for text"""
        ...

    def predict_response_patterns(
        self, text: Union[str, np.ndarray]
    ) -> np.ndarray:
        """Predict user response patterns"""
        ...

    def estimate_confidence(
        self, text: Union[str, np.ndarray]
    ) -> float:
        """Estimate coordinate confidence"""
        ...

from dlm.core.embeddings import IRCPEmbedder

embedder = IRCPEmbedder(enable_caching=True)

# Test single embedding (uses cache)
emb1 = embedder.generate_embeddings("Hello world")
assert emb1.shape == (384,)

# Cache hit
emb2 = embedder.generate_embeddings("Hello world")
assert np.array_equal(emb1, emb2)

# Batch processing
embs = embedder.generate_embeddings(["Hi", "Hello", "Hey"])
assert len(embs) == 3

# IRCP-specific features
coords = embedder.predict_coordinates("Hello")
assert coords.shape == (4,)

# dlm/engine/embedder.py

from dlm.core.embeddings import IRCPEmbedder
from dlm.response.embedding_provider import SimpleEmbeddingProvider

class Embedder:
    """Main embedding interface (backward compatible)"""

    def __init__(self, provider: str = "ircp", **kwargs):
        if provider == "ircp":
            self.provider = IRCPEmbedder(**kwargs)
        elif provider == "simple":
            self.provider = SimpleEmbeddingProvider(**kwargs)
        else:
            raise ValueError(f"Unknown provider: {provider}")

    def embed(self, text: Union[str, List[str]]):
        """Embed text using configured provider"""
        return self.provider.generate_embeddings(text)

# dlm/engine/ircp_embedder.py

import warnings
from dlm.core.embeddings import IRCPEmbedder

warnings.warn(
    "dlm.engine.ircp_embedder is deprecated. "
    "Use dlm.core.embeddings.IRCPEmbedder instead.",
    DeprecationWarning,
    stacklevel=2
)

# Compatibility shim
class IRCPEmbedder(IRCPEmbedder):
    """Deprecated: Use dlm.core.embeddings.IRCPEmbedder"""
    pass

def test_ircp_embedder_creation():
    embedder = IRCPEmbedder()
    assert embedder is not None

def test_single_embedding():
    embedder = IRCPEmbedder()
    emb = embedder.generate_embeddings("test")
    assert emb.shape == (384,)

def test_batch_embeddings():
    embedder = IRCPEmbedder()
    embs = embedder.generate_embeddings(["a", "b", "c"])
    assert len(embs) == 3

def test_caching():
    embedder = IRCPEmbedder(enable_caching=True)
    emb1 = embedder.generate_embeddings("test")
    emb2 = embedder.generate_embeddings("test")
    assert np.array_equal(emb1, emb2)
    stats = embedder.get_cache_stats()
    assert stats['hits'] == 1

def test_coordinate_prediction():
    embedder = IRCPEmbedder()
    coords = embedder.predict_coordinates("test")
    assert coords.shape == (4,)

def test_backward_compat():
    # Old import still works
    from dlm.engine.ircp_embedder import IRCPEmbedder as OldEmbedder
    embedder = OldEmbedder()
    emb = embedder.generate_embeddings("test")
    assert emb.shape == (384,)

## Embedding System

### IRCPEmbedder

Production-ready IRCP embedding provider with caching and batch processing.

#### Features
- Automatic caching (configurable TTL)
- Efficient batch processing
- Coordinate prediction
- Response pattern prediction
- Confidence estimation

#### Usage
\`\`\`python
from dlm.core.embeddings import IRCPEmbedder

# Create embedder
embedder = IRCPEmbedder(
    cache_capacity=512,
    enable_caching=True
)

# Single embedding
emb = embedder.generate_embeddings("Hello world")

# Batch embeddings
embs = embedder.generate_embeddings(["Hi", "Hello", "Hey"])

# IRCP features
coords = embedder.predict_coordinates("Hello")
patterns = embedder.predict_response_patterns("Hello")
confidence = embedder.estimate_confidence("Hello")
\`\`\`

#### Migration from dlm.engine.ircp_embedder
...