DLM Performance Optimization Plan

Explainability Tests: 10/10 passing
Pipeline Tests: 6/6 passing
Total execution time: ~5-10 seconds

# Current (inefficient)
for text in texts:
    embedding = api.embed(text)  # Individual API calls

# Optimized (batched)
embeddings = api.embed_batch(texts)  # Single API call

from functools import lru_cache
import hashlib

class CachedEmbedder:
    def __init__(self, embedder, cache_size=1000):
        self.embedder = embedder
        self.cache = {}
        self.max_size = cache_size

    def embed(self, text: str):
        # Hash text for cache key
        key = hashlib.md5(text.encode()).hexdigest()

        if key in self.cache:
            return self.cache[key]

        # Generate embedding
        embedding = self.embedder.embed(text)

        # Store in cache
        if len(self.cache) < self.max_size:
            self.cache[key] = embedding

        return embedding

from functools import lru_cache

@lru_cache(maxsize=100)
def read_file_cached(file_path: str) -> str:
    """Read file with caching."""
    with open(file_path, 'r') as f:
        return f.read()

def embed_batch(texts: List[str], batch_size: int = 32):
    """Process embeddings in batches."""
    embeddings = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        batch_embeddings = embedder.embed(batch)
        embeddings.extend(batch_embeddings)
    return embeddings

from torch.utils.data import DataLoader

class ConversationDataset(Dataset):
    def __init__(self, conversations):
        self.conversations = conversations

    def __len__(self):
        return len(self.conversations)

    def __getitem__(self, idx):
        return self.conversations[idx]

# Use DataLoader for efficient batching
dataloader = DataLoader(
    dataset,
    batch_size=32,
    num_workers=4,  # Parallel loading
    pin_memory=True,  # Faster GPU transfer
    prefetch_factor=2  # Prefetch batches
)

import asyncio
from concurrent.futures import ThreadPoolExecutor

async def save_checkpoint_async(checkpoint_data, path):
    """Save checkpoint without blocking training."""
    loop = asyncio.get_event_loop()
    with ThreadPoolExecutor() as executor:
        await loop.run_in_executor(
            executor,
            _save_checkpoint,
            checkpoint_data,
            path
        )

import torch

def optimize_gpu_memory():
    """Clear GPU cache and optimize memory."""
    if torch.cuda.is_available():
        torch.cuda.empty_cache()
        torch.cuda.synchronize()

import faiss
import numpy as np

class VectorIndex:
    def __init__(self, dimension: int):
        # Use FAISS for fast similarity search
        self.index = faiss.IndexFlatL2(dimension)
        self.ids = []

    def add(self, embeddings: np.ndarray, ids: List[str]):
        """Add embeddings to index."""
        self.index.add(embeddings.astype('float32'))
        self.ids.extend(ids)

    def search(self, query_embedding: np.ndarray, k: int = 5):
        """Fast approximate nearest neighbor search."""
        distances, indices = self.index.search(
            query_embedding.reshape(1, -1).astype('float32'),
            k
        )
        return [(self.ids[i], distances[0][idx])
                for idx, i in enumerate(indices[0])]

class LazyLoader:
    def __init__(self, file_path: str):
        self.file_path = file_path
        self._data = None

    @property
    def data(self):
        """Load data only when accessed."""
        if self._data is None:
            self._data = self._load_data()
        return self._data

    def _load_data(self):
        # Load data implementation
        pass

import mmap

def read_large_file_efficiently(file_path: str):
    """Use memory mapping for large files."""
    with open(file_path, 'r+b') as f:
        mmapped_file = mmap.mmap(f.fileno(), 0)
        return mmapped_file

import cProfile
import pstats
from functools import wraps
import time

def profile_function(func):
    """Decorator to profile function performance."""
    @wraps(func)
    def wrapper(*args, **kwargs):
        profiler = cProfile.Profile()
        profiler.enable()

        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()

        profiler.disable()

        stats = pstats.Stats(profiler)
        stats.sort_stats('cumulative')

        print(f"\n{'='*50}")
        print(f"Profile for {func.__name__}")
        print(f"Execution time: {end_time - start_time:.4f}s")
        print(f"{'='*50}\n")
        stats.print_stats(10)  # Top 10 functions

        return result
    return wrapper

# Usage
@profile_function
def slow_function():
    # Your code here
    pass

from memory_profiler import profile

@profile
def memory_intensive_function():
    """Profile memory usage."""
    # Your code here
    pass

"""
Cached Embedder - Performance Optimization

Wraps existing embedder with caching to avoid repeated API calls.
"""

from typing import List, Optional
from functools import lru_cache
import hashlib
import numpy as np


class CachedEmbedder:
    """
    Embedder with LRU caching to reduce API calls.

    Usage:
        embedder = OpenAIEmbedding()
        cached_embedder = CachedEmbedder(embedder, cache_size=1000)

        # First call - hits API
        emb1 = cached_embedder.embed("hello")

        # Second call - uses cache
        emb2 = cached_embedder.embed("hello")  # Instant!
    """

    def __init__(self, embedder, cache_size: int = 1000):
        self.embedder = embedder
        self._cache = {}
        self.cache_size = cache_size
        self.hits = 0
        self.misses = 0

    def embed(self, text: str) -> np.ndarray:
        """Embed text with caching."""
        key = self._hash_text(text)

        if key in self._cache:
            self.hits += 1
            return self._cache[key]

        self.misses += 1
        embedding = self.embedder.embed(text)

        # Add to cache if space available
        if len(self._cache) < self.cache_size:
            self._cache[key] = embedding

        return embedding

    def _hash_text(self, text: str) -> str:
        """Generate cache key from text."""
        return hashlib.md5(text.encode()).hexdigest()

    def get_stats(self):
        """Get cache statistics."""
        total = self.hits + self.misses
        hit_rate = self.hits / total if total > 0 else 0
        return {
            "hits": self.hits,
            "misses": self.misses,
            "hit_rate": hit_rate,
            "cache_size": len(self._cache)
        }

    def clear_cache(self):
        """Clear the cache."""
        self._cache.clear()
        self.hits = 0
        self.misses = 0

"""
Performance Benchmarking Script
"""

import time
import numpy as np
from dlm.inference import AI
from dlm.engine.cached_embedder import CachedEmbedder

def benchmark_embeddings(num_texts=100, cache_size=50):
    """Benchmark embedding performance with and without cache."""

    texts = [f"Sample text {i}" for i in range(num_texts)]

    # Without cache
    start = time.time()
    embedder = OpenAIEmbedding()
    for text in texts:
        embedder.embed(text)
    without_cache_time = time.time() - start

    # With cache (duplicate texts to test caching)
    texts_with_dupes = texts + texts[:cache_size]

    start = time.time()
    cached_embedder = CachedEmbedder(embedder, cache_size=cache_size)
    for text in texts_with_dupes:
        cached_embedder.embed(text)
    with_cache_time = time.time() - start

    stats = cached_embedder.get_stats()

    print(f"Without cache: {without_cache_time:.2f}s")
    print(f"With cache: {with_cache_time:.2f}s")
    print(f"Speedup: {without_cache_time / with_cache_time:.2f}x")
    print(f"Cache stats: {stats}")

if __name__ == "__main__":
    benchmark_embeddings()